Leandro Nunes

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:

• Configurando o NetBeans para utilizar a jMoney Engine
• Entendendo a jMonkey Engine

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 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();
    }   
}

Os recursos fornecidos pela SimpleGame são:

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

• 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á!