sexta-feira, 28 de dezembro de 2012

Time's Up com ficheiros

Aparentemente não demorou muito tempo, tal como tinha dito no post anterior seria interessante que os tempos guardados pudessem ser recuperados para sessões posteriores, assim adicionei dois botões à interface.



O botão Gravar vai gravar num ficheiro de texto os dados relativos aos tempos intermédios.
O botão Limpar, tal como o nome indica, apaga os tempos da textview não do ficheiro.

O código


A função associada ao botão Limpar:
    //função para limpar a textview 2
    public void bt_limpar_click(View v){
    tv2.setText("");
    }
Simples, sem comentários.


Agora a função associada ao botão Gravar:

    //gravar no ficheiro os tempos
    public void bt_gravar_click(View v){
    try{
    File myfile = new File(ficheiro);
    myfile.createNewFile();
    FileOutputStream fOut = new FileOutputStream(myfile);
    OutputStreamWriter myOutWriter = new OutputStreamWriter(fOut);
    myOutWriter.append(tv2.getText());
    myOutWriter.close();
    fOut.close();
    showMessage("Gravado com sucesso!");
    }catch (Exception ex){
    showMessage(ex.getMessage());
    }
    }
Nesta função criamos um ficheiro e associamos um Output Stream a esse ficheiro que depois utilizamos para gravar o conteúdo do textView2.

Por fim a função que abre e lê o ficheiro sempre que a aplicação é iniciada:
    //função para ler o ficheiro e adicionar à textview
    public void ler_ficheiro(){
    try{
    File myfile = new File(ficheiro);
    FileInputStream fIn = new FileInputStream(myfile);
    BufferedReader myReader = new BufferedReader(new InputStreamReader(fIn));
   
    String aDataRow="";
    String aBuffer="";
    while((aDataRow=myReader.readLine())!=null){
    aBuffer +=aDataRow + "\n";
    }
    tv2.setText(aBuffer);
    myReader.close();
    showMessage("Tempos carregados!");
    }catch (Exception ex){
   
    }
    }
Esta função é chamada na função onCreate.

Não nos podemos esquecer de adicionar ao manifesto da aplicação a permissão com a seguinte linha:
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

E assim temos um projeto completo, o próximo passo é visual, tenho de começar a ter mais cuidado com a interface, até agora tem sido só atirar botões e textviews para o ecrã e depois se vê.

A nova versão do projeto e da aplicação.

Time's Up

De volta à plataforma Android desta vez para fazer um pequeno programa que vai permitir cronometrar e guardar tempos.

A interface é simples:



O botão Guardar vai permitir adicionar o tempo atual aos tempos intermédios. O botão Iniciar vair intercalar a interface entre a hora atual e o cronometro. O botão Recomeçar vai recolocar o temporizador a zero.

Sempre que carregar no botão Guardar o tempo do cronometro é adicionado aos tempos intermédios o que  implica ter uma área que se pode deslizar para cima e para baixo uma vez que não existe limite no número de tempos que podemos adicionar.


Os desafios deste pequeno programa são dois:
- primeiro a atualização da interface implica criar uma thread separada, de outro modo o sistema não atualiza a informação mostrada ao utilizador.
- segundo temos os cálculos com tempo, neste aspeto encontrei um problema inesperado! O programa apresenta resultados diferentes quando executado no emulador de quando é executado no dispositivo real. Ainda não percebi porquê mas testei com duas versões diferentes do emulador e os resultados foram os mesmos, mas quando executei num Huawei com a versão 4.0.3 do Android os resultados não coincidiam com  os apresentados pelo emulador.

A interface

Vamos começar pela interface. O código é:

<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="wrap_content" >

    <Button
        android:id="@+id/bt_start"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentLeft="true"
        android:layout_alignParentTop="true"
        android:onClick="bt_guardar_click"
        android:text="@string/guardar" />

    <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentLeft="true"
        android:layout_below="@+id/bt_start"
        android:layout_marginTop="16dp"
        android:textAppearance="?android:attr/textAppearanceMedium" />

    <TextView
        android:id="@+id/textView2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentLeft="true"
        android:layout_below="@+id/textView1"
        android:textAppearance="?android:attr/textAppearanceMedium" />

    <Button
        android:id="@+id/bt_iniciar"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:layout_marginLeft="20dp"
        android:layout_toRightOf="@+id/bt_start"
        android:onClick="bt_iniciar_click"
        android:text="@string/inicio" />

    <Button
        android:id="@+id/bt_continuar"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:layout_marginLeft="20dp"
        android:layout_toRightOf="@+id/bt_iniciar"
        android:onClick="bt_continuar_click"
        android:text="@string/reiniciar" />

    <TextView
        android:id="@+id/textView3"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignBaseline="@+id/textView2"
        android:layout_alignBottom="@+id/textView2"
        android:layout_toRightOf="@+id/bt_start"
        android:text="@string/intermedios"
        android:textAppearance="?android:attr/textAppearanceLarge" />

</RelativeLayout>
</ScrollView>


Resumindo temos:
- 1 scrollview para podermos deslizar o conteúdo
- 3 botões
- 3 Textviews: 1 para mostrar a hora ou o tempo cronometrado, 1 para o texto "Intermédios" e por fim para os tempos intermédios guardados.

O código

Em relação ao código vamos apresentar a função on create

    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_times_up);
        tv1=(TextView) findViewById(R.id.textView1);
        tv2=(TextView) findViewById(R.id.textView2);
        iniciado=false;

        //thread que vai atualizar a UI
        Thread th = new Thread(){
        @Override
        public void run(){
        while(true){
        try {
Thread.sleep(250);
} catch (InterruptedException e) {
e.printStackTrace();
}
        runOnUiThread(new Runnable(){
        public void run(){
        String t;
        if(!iniciado){
                 cal = Calendar.getInstance();
               t=String.format("%02d:%02d:%02d",cal.get(Calendar.HOUR_OF_DAY),cal.get(Calendar.MINUTE),cal.get(Calendar.SECOND));
        tv1.setText(t);
        }else{
                 int m=0,h=0,s=0;
               
                 cal = Calendar.getInstance();
                 cal.setTimeInMillis(cal.getTimeInMillis()-inicio.getTimeInMillis());
                 //h=cal.get(Calendar.HOUR_OF_DAY);
                 h=(int)cal.getTimeInMillis()/(1000*60*60);
        m=cal.get(Calendar.MINUTE);
        s=cal.get(Calendar.SECOND);
        t=String.format("%02d:%02d:%02d",h,m,s);
        tv1.setText(t);// + "-" + Long.toString(mil));
    } //if else
        }//run
        });//runOnUiThread
        }//whiler
        }//run
        };//thread
        th.start();
    }//oncreate

Este código cria um ciclo infinito que vai atualizar e apresentar a hora ou o tempo cronometrado de acordo com a variável "iniciado" que indica se o cronometro foi ou não iniciado.

A linha de código que está comentada é a que apresenta um valor diferente quando executada no emulador de quando executada no dispositivo real. Esta linha devia calcular quantas horas correspondem ao valor de milissegundos calculados como diferença entre o tempo inicial do cronometro e o atual. No emulador o valor é calculado corretamente como sendo zero inicialmente enquanto que no dispositivo começa em um!! Vai-se lá saber porquê.
Esta é a imagem do programa a correr no dispositivo real.
 E esta é a imagem do programa a correr no emulador.
Para resolver este problema decidi calcular a hora de outro modo utilizando a linha

                 h=(int)cal.getTimeInMillis()/(1000*60*60);


Por fim criei um menu com duas opções:

<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/item1" android:title="Sobre"></item>
    <item android:id="@+id/item2" android:title="Sair"></item>
</menu>

O código que cria o menu e responde às opções é apresentado a seguir:
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_times_up, menu);
        return true;
    }
    //opções do menu
    public boolean onOptionsItemSelected(MenuItem item) {
if(item.getTitle().toString().equals("Sobre"))
showMessage("Paulo Ferreira");
if(item.getTitle().toString().equals("Sair")){
showMessage("That's all folks!");
finish();
}
return true;
  }

A primeira função é criada pelo Eclipse automaticamente enquanto que a segunda é a que reage ao clique nas opções dos menus.
A função showMessage é foi apresentada noutros projetos e somente cria uma Toast com o texto que lhe foi passado:
    /* mostra o texto passado numa pequena mensagem */
    private void showMessage(CharSequence text) {
    Context context = getApplicationContext();
int duration = Toast.LENGTH_SHORT;
//faz aparecer uma mensagem pequena durante um certo tempo
Toast toast = Toast.makeText(context, text, duration);
toast.show();    
    }

Por fim temos as funções que implementam a lógica dos três botões:
    //botão guardar
    public void bt_guardar_click(View v){
    String t;
   
    t=(String) tv2.getText();
    t = t + "\n" + tv1.getText();
    tv2.setText(t);
    }
    //botão iniciar
    public void bt_iniciar_click(View v){
    if(inicio==null)
    inicio = Calendar.getInstance();
    iniciado=!iniciado;
    }
    //botão recomeçar
    public void bt_continuar_click(View v){
    inicio = Calendar.getInstance();
    }

Um dos problemas que ainda temos para resolver é o que acontece quando mudamos a orientação do dispositivo, uma vez que o programa é reiniciado o tempo do temporizador perdido. Assim podemos fixar a orientação em vertical (portait) com a seguinte linha:
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

Basta adicionar no inicio da função onCreate.

Uma funcionalidade que fica para depois, espero que não muito depois, é adicionar a possibilidade de guardar os tempos para mais tarde poder recarregar e comparar.

Como sidekick temos uma caraterística interessante que permite que o programa mesmo não estando aberto em primeiro plano continua a calcular o tempo no cronometro graças ao modo como o Android executa os programas, assim podemos ter o programa aberto a executar em modo cronometro e atender chamadas ou executar outro programa que quando voltamos o tempo continua.


sábado, 1 de dezembro de 2012

Bicionário - Windows Phone

Depois da versão Android fica aqui a versão Windows Phone.




Para este pequeno projeto vamos utilizar o Visual Studio 2010 Express for Windows Phone, a linguagem utilizada é o Visual Basic.

Começamos por criar o projeto novo.


Depois criamos a interface com dois radio buttons, uma textbox, um botão e um textblock.


Ainda antes de começar a codificar vamos precisar de adicionar os dois ficheiros txt ao projeto para podermos aceder a eles quando for necessário verificar a palavra introduzida. Para isso basta arrastar os ficheiros para o Solution Explorer.
Depois temos de alterar as propriedades dos dois ficheiros para que sejam compilados como recursos, assim com o botão direito do rato abrimos as propriedades dos ficheiros e alteramos a propriedade Build Action para Resource.

 As hipóteses são:

Agora o código no botão verificar, basta fazer duplo clique para abrir o editor do evento click no botão e inserir o seguinte código:

Private Sub Button1_Click(sender As System.Object, e As System.Windows.RoutedEventArgs) Handles Button1.Click
        Dim palavra As String
        Dim linha As String
        Dim encontra As Boolean
        Dim streamreaderinfo As System.Windows.Resources.StreamResourceInfo

        encontra = False
        palavra = Me.TextBox1.Text
        If palavra.Length = 0 Then
            MessageBox.Show("Preencha com uma palavra por favor!")
            Exit Sub
        End If
        palavra = palavra.ToLower()
        If Me.RadioButton2.IsChecked() = True Then 'português
            streamreaderinfo = Application.GetResourceStream(New Uri("BidicionarioWP;component/portugues.txt", UriKind.Relative))
        Else
            streamreaderinfo = Application.GetResourceStream(New Uri("BidicionarioWP;component/ingles.txt", UriKind.Relative))
        End If

        Me.TextBlock1.Text = "A pesquisar..."
        Try
            Using f As New IO.StreamReader(streamreaderinfo.Stream)
                Do While f.EndOfStream = False
                    linha = f.ReadLine()
                    linha = linha.ToLower()
                    If linha = palavra Then
                        encontra = True
                        Exit Do
                    End If
                Loop
            End Using
        Catch ex As Exception
            MessageBox.Show("Erro no acesso ao ficheiro: " & ex.Message)
            Exit Sub
        End Try

        If encontra = False Then
            Me.TextBlock1.Text = "Palavra não encontrada!"
            MessageBox.Show("Palavra não encontrada!")
        Else
            Me.TextBlock1.Text = "Palavra encontrada!"
            MessageBox.Show("Palavra encontrada!")
        End If

    End Sub

Este código é muito mais simples do que a versão Android e a execução no emulador também é muito mais rápida, a Microsoft já aprendeu há muito tempo que as ferramentas de programação são fundamentais.

Quem já programou em VB.NET vai achar o código muito parecido com o que tem utilizado, incluindo a função que permite apresentar pequenas mensagens (messagebox).

A principal diferença está no modo como referenciamos os ficheiros de texto porque neste caso eles estão inseridos como recursos no projeto e não como ficheiro isolados no sistema de ficheiros do dispositivo.

Uma última palavra sobre o emulador do Windows Phone que é muito rápido e estável comparativamente com o emulador Android que é bastante pesado e lento.

O projeto pode ser picado aqui.

sexta-feira, 30 de novembro de 2012

Um bicionário = dicionário com duas línguas

Para este post pensei criar um "bicionário" para Android, isto é, um programa que permite verificar se uma palavra existe em duas línguas, neste caso Português e Inglês.




Depois de pesquisar na Net consegui dois ficheiros de texto com uma lista de palavras, um em português outro em inglês.

Então começamos com a interface, muito simples, duas textviews, uma edittext, dois radio buttons dentro de um radioGroup, por fim um botão.

O código XML é


<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentLeft="true"
        android:layout_alignParentTop="true"
        android:layout_marginTop="14dp"
        android:text="@string/dicionario"
        tools:context=".MainActivity" />

    <RadioGroup
        android:id="@+id/radioDic"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@id/textView1" >
        
    <RadioButton
        android:id="@+id/radioButton1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:checked="true"
        android:text="@string/pt" />
        
    <RadioButton
        android:id="@+id/radioButton2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:checked="false"
        android:text="@string/ing" />
    
 </RadioGroup>

   <EditText
       android:id="@+id/editText1"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:layout_alignParentLeft="true"
       android:layout_below="@+id/radioDic"
       android:ems="10"
       android:inputType="text" >
    
        <requestFocus />
    </EditText>

    <Button
        android:id="@+id/button1"
        style="?android:attr/buttonStyleSmall"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignBaseline="@+id/editText1"
        android:layout_alignBottom="@+id/editText1"
        android:layout_alignParentRight="true"
        android:onClick="bt_verificar"
        android:text="@string/botao" />

    <TextView
        android:id="@+id/textView2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/button1"
        android:textAppearance="?android:attr/textAppearanceLarge" />

</RelativeLayout>

Para que o código possa ler os ficheiros temos de os colocar nas pasta res\raw. Os ficheiros colocados nesta pasta são mantidos inalterados dentro da estrutura do projeto.

Quando o botão Verificar é clicado temos de ler o ficheiro correspondente ao dicionário escolhido e procurar a palavra inserida.

Para tal criamos uma função que recebe a palavra e a opção pelo dicionário e devolve true ou false em função como resultado da pesquisa.

private boolean encontra(String palavra,int dic){
    boolean resultado;
    InputStream is;
   
    if(dic==0)
      //carrega dicionario PT
    is = getResources().openRawResource(R.raw.portugues);
    else
    is = getResources().openRawResource(R.raw.ingles);
   
    Scanner pesquisa=new Scanner(is);
    Log.d(TAG,"Português!");
    resultado=false;
    while(pesquisa.hasNext()){
String linha=pesquisa.nextLine();
linha=linha.toLowerCase();
if(linha.equals(palavra)){
resultado=true;
break;
}
    }//while
    pesquisa.close();
try {
is.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
    return resultado;
    }

O problema começa quando tentamos pesquisar uma palavra e o sistema operativo indica que o programa não está a responder, isto devesse ao tempo que demora a percorrer o ficheiro, assim foi necessário criar uma thread para que esta função seja executada em background enquanto mantemos na interface uma animação que indica que a pesquisa está a decorrer.

Esta é a função que é chamada quando o botão Verificar é clicado:
    //botão para verificar palavra
    public void bt_verificar(View view){
    Runnable runnable=new Runnable(){
    public void run(){
EditText texto=(EditText)findViewById(R.id.editText1); //texto introduzido
final Button bt =(Button)findViewById(R.id.button1); //botão verificar
final TextView mensagem=(TextView)findViewById(R.id.textView2); //textview para mostrar mensagem
int l=0;
if(texto.getText().length()==0){
showMessage("Introduza uma palavra a pesquisar!");
return;
}//if
String palavra=texto.getText().toString();
palavra=palavra.toLowerCase();
Log.d(TAG,"A pesquisar " + palavra);
RadioButton rbDicionario=(RadioButton)findViewById(R.id.radioButton1);  //botão radio
if(rbDicionario.isChecked())
l=0; //português
else
l=1; //inglês
handler.post(new Runnable() {
public void run() {
bt.setEnabled(false);
setProgressBarIndeterminateVisibility(true);
mensagem.setText("A Pesquisar...");
}
 });
if(encontra(palavra,l)){
handler.post(new Runnable() {
 //  @Override
public void run() {
bt.setEnabled(true);
setProgressBarIndeterminateVisibility(false);      
mensagem.setText("Palavra encontrada!");
showMessage("Palavra encontrada!");
}
 });
}else{
handler.post(new Runnable() {
 //  @Override
public void run() {
bt.setEnabled(true);
setProgressBarIndeterminateVisibility(false);           
mensagem.setText("Palavra não encontrada!");
showMessage("Palavra não encontrada!");
}
 });
}
    }
    };
    new Thread(runnable).start();
    }

Ao executar este código numa thread é necessário criar uma handler para podermos atualizar a interface do utilizador.

Na interface também foi adicionada por código uma progressBar que aparece e desaparece de acordo com o código que está a ser executado.

O código completo da aplicação fica assim:
package edu.pjcferreira.bicionario;

import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;
import android.os.Bundle;
import android.os.Handler;
import android.app.Activity;
import android.content.Context;
import android.util.Log;
import android.view.Menu;
import android.view.View;
import android.view.Window;
import android.widget.Button;
import android.widget.EditText;
import android.widget.RadioButton;
import android.widget.TextView;
import android.widget.Toast;

public class MainActivity extends Activity {
private static final String TAG = MainActivity.class.getSimpleName();
private Handler handler;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
        
        setContentView(R.layout.activity_main);

        setProgressBarIndeterminateVisibility(false);
        handler= new Handler();
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }
    
    private void showMessage(CharSequence text){
    Context context=getApplicationContext();
    int duration=Toast.LENGTH_SHORT;
    Toast toast=Toast.makeText(context, text, duration);
    toast.show();
    }
    //botão para verificar palavra
    public void bt_verificar(View view){
    Runnable runnable=new Runnable(){
    public void run(){
EditText texto=(EditText)findViewById(R.id.editText1); //texto introduzido
final Button bt =(Button)findViewById(R.id.button1); //botão verificar
final TextView mensagem=(TextView)findViewById(R.id.textView2); //textview para mostrar mensagem
int l=0;
if(texto.getText().length()==0){
showMessage("Introduza uma palavra a pesquisar!");
return;
}//if
String palavra=texto.getText().toString();
palavra=palavra.toLowerCase();
Log.d(TAG,"A pesquisar " + palavra);
RadioButton rbDicionario=(RadioButton)findViewById(R.id.radioButton1);  //botão radio
if(rbDicionario.isChecked())
l=0; //português
else
l=1; //inglês
handler.post(new Runnable() {
public void run() {
bt.setEnabled(false);
setProgressBarIndeterminateVisibility(true);
mensagem.setText("A Pesquisar...");
}
 });
if(encontra(palavra,l)){
handler.post(new Runnable() {
 //  @Override
public void run() {
bt.setEnabled(true);
setProgressBarIndeterminateVisibility(false);      
mensagem.setText("Palavra encontrada!");
showMessage("Palavra encontrada!");
}
 });
}else{
handler.post(new Runnable() {
 //  @Override
public void run() {
bt.setEnabled(true);
setProgressBarIndeterminateVisibility(false);           
mensagem.setText("Palavra não encontrada!");
showMessage("Palavra não encontrada!");
}
 });
}
    }
    };
    new Thread(runnable).start();
    }

    private boolean encontra(String palavra,int dic){
    boolean resultado;
    InputStream is;
   
    if(dic==0)
      //carrega dicionario PT
    is = getResources().openRawResource(R.raw.portugues);
    else
    is = getResources().openRawResource(R.raw.ingles);
   
    Scanner pesquisa=new Scanner(is);
    Log.d(TAG,"Português!");
    resultado=false;
    while(pesquisa.hasNext()){
String linha=pesquisa.nextLine();
linha=linha.toLowerCase();
if(linha.equals(palavra)){
resultado=true;
break;
}
    }//while
    pesquisa.close();
try {
is.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
    return resultado;
    }
}

Fica aqui o projeto e a aplicação.

sexta-feira, 23 de novembro de 2012

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.