jump to navigation

Half Life 1 no Ubuntu 9.04 06/07/2009

Posted by Leandro Nunes in Jogos, Ubuntu.
Tags: , , , , ,
3 comments

Esse post é apenas um post comemorativo da minha volta ao mundo dos Jogos, como jogador :-). Instalei ontem o Half Life 1 (eu sei que é velho, não precisa reforçar…) no meu Ubuntu 9.04 usando o Wine.

Funcionou tudo 100%, não precisei fazer esforço nenhum, por isso esse post não virou um tutorial. Simplesmente por que não houve esforço. Instalei o Wine:

sudo apt-get install wine

E instalei o Half Life dando um duplo clique no AUTORUN.exe do CD-ROM que eu comprei. Sério! sem dor, sem dependencias de nenhum tipo :-). O jogo funcionou na resolução máximo, com tudo no máximo e olha que minha máquina está longe de ser um top de linha (Pentium Dual-Core, 2Gb de ram, Vídeo X3100 da Intel). Aqui tem um Screenshot da primeira fase (~900Kb), pra quem não conheça…

jMonkey Básico: a classe SimpleGame 15/11/2008

Posted by Leandro Nunes in Java, Jogos, NetBeans, Programação Geral.
Tags: , , , , ,
2 comments

Prosseguindo com a série de artigos sobre jMonkey, que já conta com dois posts no blog passamos agora para um exemplo básico programa desenvolvido com jMonkey para testar algumas de suas funcionalidades.

Não deixe de ler:

2784150

Para fins deste tutorial, considera-se que você tenha um ambiente jMonkey configurado e funcionando, não importando que IDE você utiliza nem Sistema operacional.

Nosso objetivo para este tutorial é entender um pouco mais sobre:

  • Fluxo de um game genérico utilizando jMonkey e
  • Funcionamento da classe SimpleGame.

Dependendo da classe GameType utilizada (SimpleGame é uma delas), o nível de abstração de seu game será maior (onde a jMonkey Engine oferece mais recursos ao desenvolvedor) ou menor (deixando livre para o desenvolvedor fazer as escolhas de como as coisas vão ser implementadas).

Um conceito importante a ser entendido neste momento é o conceito de “Game Loop”:

game-loop1Game Loop, é o fluxo de execução de um game que,  na abordagem da jMonkey consiste em sete passos principais: Inicialização do sistema; Inicialização do game; Início do loop; Atualização dos dados do game; renderização dos dados atualizados; Verificação do estado atual do game e Finalização. A figura ao lado ilustra esse fluxo, clique para ampliar.

A jMonkey Engine oferece um conjunto de classes que implementa esse GameLoop. (BaseGame, SimpleGame, StandardGame, SimplePassGame, BaseHeadlessApp, entre muitas outras…) Neste tutorial, pretendo detalhar o funcionamento de uma dessas classes, a SimpleGame.

SimpleGame

A classe SimpleGame oferece um cenário de desenvolvimento de games bem completo para o desenvolvedor, descomplicando o processo de criação de games.

Vale lembrar que na jMonkey Engine, todas as cenas são baseadas em um grafo de objetos que é renderizado. Utilizando SimpleGame, a jMonkey Engine fornece inclusive o nodo raiz, no qual o desenvolvedor deverá anexar seus objetos (esse nodo pode ser acessado através de um objeto chamado rootNode).

Um esqueleto básico de programa (vazio) que demonstra SimpleGame é mostrado abaixo.

import com.jme.app.SimpleGame;
public class SimpleGameSample extends SimpleGame {

    protected void simpleInitGame() { }

    @Override
    protected void simpleUpdate() {   }

    public static void main(String args []) {
        SimpleGameSample game = new SimpleGameSample();
        game.start();
    }   
}

Bem, se você testou esse programa, já foi possível ver uma magnífica…. tela vazia… vamos detalhar agora os recurso que são fornecidos nessa tela. Para isso, temos que desenhar alguma coisa nela. Que tal uma seta ? pra começar tá legal.

import com.jme.app.SimpleGame;
import com.jme.scene.shape.Arrow;
public class SimpleGameSample extends SimpleGame {
    Arrow a;
    protected void simpleInitGame() {
        a = new Arrow("Arrow",10,5);
        rootNode.attachChild(a);
    }

    @Override
    protected void simpleUpdate() {
    }

    public static void main(String args []) {
        SimpleGameSample game = new SimpleGameSample();
        game.start();
    }   
}

simplegamescreenshotOs recursos fornecidos pela SimpleGame são:

  • Acesso ao InputHandler (manipulador de entradas) para tratamento de teclado e mouse;

atalhos-jmonkey

  • Uma Câmera posicionada na coordenada (0,0,25) apontada (significa que ela está “olhando”) para (0,0,-1) e que pode ser acessada pelo objeto chamado “cam”;
  • Um ponto de luz branca posicionado em (100,100,100) e já adicionado ao nodo raiz. Essa luz por ser desabilitada pelo atalho “L” ou por uma chama (em código) do método lightState.setEnabled(false);
  • Um timer, criado e gerenciado pela infra-estrutura para controlar tempo gasto para renderização dos frames que é sempre mostrado no rodapé quando se está utilizando SimpleGame;
  • Por último o objeto rootNode, já citado, que é o nodo raiz, que é o ponto inicial onde o renderizado procurar “coisas que devem ser desenhadas”. À este nodo, os objetos padrão do game são anexados.

Métodos:

  • simpleInitGame(): único método que obrigatóriamente deve ser implementado quando se utiliza SimpleGame. É neste método é que os objetos da cena deve ser criados;
  • simpleUpdate(): é o método chamado a cada atualização da tela. Neste método que são implementadas as mudanças de estado do game, bem como detecção de colisão e movimentação dos componentes da cena;
  • simpleRender(): esse método é chamado como último passo antes do renderizador finalizar uma cena. É o lugar onde são colocadas as renderizações de textura e os objetos que devem ser desenhados mas não estão anexados ao rootNode.

No próximo tutorial irei abordar os assuntos: “Formas Básicas” e “Texturas”. Até lá!

Configurando o NetBeans para utilizar JMonkey Engine 21/09/2008

Posted by Leandro Nunes in Java, Jogos, NetBeans, Programação Geral, Software Livre, Ubuntu.
Tags: , , , ,
3 comments

Dando continuidade ao que foi abordado no outro post (Entendendo a JMonkey Engine), passamos agora uma opção de configuração do ambiente de desenvolvimento (neste caso, NetBeans) para trabalhar com o framework JMonkey.

A configuração é relativamente simples para quem tem experiência com a ferramenta. Destaco que está pode não ser a melhor configuração, com certeza existem outras formas de atingir o mesmo resultado. Ainda assim, ao final deste tutorial, você deve ser capaz de desenvolver e executar suas aplicações com o uso deste framework.

A configuração de divide em duas partes, imprescindíveis, para que voce possa:

  • Desenvolver programas com JMonkey Engine
  • Rodar aplicações desenvolvidas com a JMonkey Engine em seu sistema operacional

Passo 1: Fazendo o download do software necessário

- Faça o download da JMonkey Engine (quando escrevi isso, usei a versão 1.0), disponível aqui. Esses arquivos contém todas as classes da JMonkey para você compilar seus programas Java que utilizem o  framework.

- Faça o download da LWJGL (enquanto escrevo este post, a versão mais atual é a 1.1.4)…. LWJGL ? sim, você vai precisar dessas bibliotecas tanto para escrever seus programas, quanto para excutá-los… (não sabe o que é a LWJGL ? aqui tem mais informações).

*Para o nosso objetivo você não precisa ser um especialista em LWJGL, mesmo assim, é bom saber que LWJGL é uma biblioteca multiplataforma que faz, entre outras coisas, a comunicação entre seus programas Java, diretamente com o baixo nível de renderização da OpenGL, e que existem implementações para cada plataforma de Sistema Operacional.

- Descompacte os dois arquivos (jme.zip e lwjgl-1.1.4.zip), e vamos para o próximo passo.

Passo 2: Configurando o ambiente e criando um novo projeto com NetBeans

Esse tutorial parte da premissa que você tem JSDK e Netbeans, instalados e funcionando. Realizei os experimentos no meu Ubuntu 8.04, com NetBeans 6.1 e Java 1.6 (OpenJDK 1.6), mas os conceitos valem para este ambiente em qualquer sistema operacional que você estiver executando.

- Crie um novo projeto do NetBeans: “File” > “New Project”

- Selecione as opções: Categories: “Java” e Projects: “Java Application” e clique “Next”.

- Agora você deve dar um nome para seu projeto. Em nosso exemplo, o nome do projeto é JMonkeyTest

Configure como está mostrado na figura abaixo.

- Agora é hora de adicionar as bibliotecas necessárias para criar aplicações com JMonkey. Por uma questão didática, o projeto está configurado para copiar as bibliotecas adicionadas para a pasta do projeto.

Dois conjuntos de bibliotecas devem ser adicionados ao seu projeto: as do JMonkey e as da LWJGL. A ordem que você adiciona não faz diferença. Vamos começar pela JMonkey.

- Clique no seu projeto para expandir os itens “Source Packages”, “Test Packages”, “Libraries” e “Test Libraries”. Em seguida, clique com o botão direito na opção “Libraries”, opção “Add JAR/Folder”. Vá até o diretório onde você descompactou o arquivo jme.zip. Selecione todos os arquivos e marque a opção “Copy to Libraries Folder”(a opção padrão já é seu diretório lib, do raiz de seu projeto). Clique “OK”.

- Faça o mesmo para os arquivos da LWJGL. Desta vez, selecione os arquivos que estão no diretório “jar“, a partir da pasta onde a LWJGL foi descompactada (esta tarefa foi feita no passo 1).

Com esses dois passos simples, você adicionou todas as bibliotecas necessárias para COMPILAR seus programas.

Para executar o que já foi compilado com JMonkey, precisamos informar a localização de algumas bibliotecas que são fornecidas pelo LWJGL, no diretório “native” e que dependem do seu sistema operacional.

IMPORTANTE: Se você não configurar essas bibliotecas nativas, seus programas vão compilar mas não vão rodar.

Para solucionar o problema, vamos informar a localização das bibliotecas como parâmetro para execução. Para isso, clique com o botão direito no seu projeto “JMonkeyTest” OU vá ao menu “File”, opção “JMonkeyTest Properties”. A seguir, clique na opção “Run” e preencha o campo “VM Options”, com o seguinte conteúdo:

-Djava.library.path=[caminho para a pasta LWJGL/native/[seu sistema operacional]]

No meu caso, ficou assim

-Djava.library.path=/home/leandro/Desktop/lwjgl-1.1.4/native/linux

Agora vamos criar um arquivo exemplo e testar tudo isso que foi configurado:

- Com o projeto aberto, crie uma nova classe e dê o nome de “JMonkeyTest”. Será criado um arquivo JMonkeyTest.java.

Aí está minha sugestão de programa de teste, baseada em um exemplo do guia de usuário do JMonkey, que você poderá baixar aqui. Lembre-se que nosso foco agora está em configurar nosso ambiente para desenvolvimento com a JMonkey.

/**
  *  Teste JMonkey Engine
  *
  * @author Leandro Nunes
  * @since 09/21/2008
  */
 import com.jme.app.SimpleGame;
 import com.jme.bounding.BoundingBox;
 import com.jme.math.Vector3f;
 import com.jme.scene.shape.Sphere;

 public class JMonkeyTest extends SimpleGame{

     private Sphere s;

     public static void main(String[] args) {
         JMonkeyTest app = new JMonkeyTest();
         app.setDialogBehaviour(ALWAYS_SHOW_PROPS_DIALOG);
         app.start();
 } 

 protected void simpleUpdate() {
 }

 protected void simpleInitGame() {
    s = new Sphere("Sphere", 63, 50, 25);
    s.setLocalTranslation(new Vector3f(0,0,-40));
    s.setModelBound(new BoundingBox());
    s.updateModelBound();
    rootNode.attachChild(s);
   }
 }

Para rodar o código, pressione <F6>.

Quando você executar, se estiver tudo de acordo com as configurações que passei acima, você deve ver alguma coisa parecida com isso:

Depois de configurar a resolução, aparecerá alguma coisa semelhante a isso:

Se aparecer essa tela, sua configuração foi efetuada com sucesso! Para novos projetos é só seguir a configuração e criar seu próprio código.

Por enquanto é só pessoal.

Mais detalhes podem ser obtidos na documentação oficial (em inglês, claro!) que você poderá baixar aqui.

Cenas dos próximos episódios: uma vez que temos nosso ambiente configurado e sabemos executar as aplicações desenvolvidas, podemos passar ao desenvolvimento de aplicaçõe didáticas simples para iniciar os estudos com JMonkey. Até lá…