jMonkeyEngine 3 Tutorial (4) - Hello Update Loop

package jme3test.helloworld;

import com.jme3.app.SimpleApplication;
import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.math.Vector3f;
import com.jme3.scene.Geometry;
import com.jme3.scene.shape.Box;

/** Sample 4 - how to trigger repeating actions from the main update loop.
 * In this example, we make the player character rotate. */
public class HelloLoop extends SimpleApplication {

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

    protected Geometry player;

    @Override
    public void simpleInitApp() {

        Box b = new Box(Vector3f.ZERO, 1, 1, 1);
        player = new Geometry("blue cube", b);
        Material mat = new Material(assetManager,
          "Common/MatDefs/Misc/Unshaded.j3md");
        mat.setColor("Color", ColorRGBA.Blue);
        player.setMaterial(mat);
        rootNode.attachChild(player);
    }

    /* This is the update loop */
    @Override
    public void simpleUpdate(float tpf) {
        // make the player rotate
        player.rotate(0, 2*tpf, 0);
    }
}----
Compile e execute o arquivo: Você vê um cubo rotacionando constantemente.



== Entendendo o Código

Comparado a nossos exemplos de código anteriores você nota que a geometria (Geometry) do jogador é agora um campo (atributo) de classe. Isto é porque nós queremos que o loop de atualização seja capaz de acessar e transformar esta geometria (Geometry). Como notmal, nós inicializamos o objeto jogador no método `simpleInitApp()`.


Agora dê uma olhada mais de perto no método `simpleUpdate()` – este é o loop de atualização.


*  A linha `player.rotate(0, 2*tpf, 0);` muda a rotação do objeto jogador.
*  Nós usamos a variável `tpf` (tempo por quadro) (“time per frame) para temporizar esta ação dependendo da taxa atual de quadros por segundo. Isto simplesmente significa que o cubo rotaciona com a mesma velocidade em máquinas rápidas e lentas, e o jogo permanece jogável.
*  Quando o jogo executa, o código rotate() é executado repetidamente.


== Usando o Loop de Atualização

Um objeto rotacionando é apenas um exemplo simples. No loop de atualização, você tipicamente tem muitos testes e dispara várias ações de jogo. Isto é onde você atualiza a pontuação e pontos de vida, checa por colisões, faz os inimigos calcularem o próximo movimento deles, rola os dados se uma armadilha foi colocada, toca sons ambiente aleatórios, e muito mais.


*  O método `simpleUpdate()` inicia sua execução após o método `simpleInitApp()` ter inicializado o grafo de cena e as variáveis de estado.
*  JME3 executa tudo no método simpleUpdate() repetidamente, tão rápido quanto possível.
..  Use o loop para consultar o estado do jogo e então inciar ações.
..  Use o loop para disparar reações e atualizar o estado do jogo.
..  Use o loop com sabedoria, por que ter chamadas demais no loop também faz o jogo mais executar mais lento.



== Inicializar - Atualizar - Renderizar

Note o contraste:


*  O método `simpleInitApp()` é executado somente uma vez, imediatamente no início;
*  O método `simpleUpdate()` executa repetidamente, durante o jogo.
*  Depois de toda atualização a jMonkeyEngine automaticamente redesenha (renderiza) a tela para você!

Desde que rendering é automático e, inicialização e a atualiação são os dois conceitos mais importantes em uma SimpleApplication para você imediatamente. Estes métodos são onde você carrega e cria dados do jogo (uma vez), e (repetidamente) muda as propriedades deles para atualizar o estado do jogo:


*  `simpleInitApp()` é a “primeira respiração da aplicação.
*  `simpleUpdate()` é a batida de coração da aplicação. +
A unidade de tempo de atualização é chamada `tiques (ticks)`.




*  Mova os blocos de código do método simpleInitApp() para <<jme3/advanced/application_states#, AppStates>>.
*  Mova os blocos de código do método simpleUpdate() para <<jme3/advanced/custom_controls#,Custom Controls>>.






== Exercícios

Aqui estão algumas coisas divertidas para experimentar:


.  O que acontece se você dar ao método rotate() números negativos?
.  Você pode criar duas geometrias (Geometries) uma próxima a outra, e fazer uma rotacionar duas vezes mais rápido que a outra? (use a varuável `tpf`)
.  Você pode fazer um cubo que pulsa (cresce e diminui)
.  Você pode fazer um cubo que muda de cor? (mude e configure o Material)
.  Você pode fazer um cubo que role (rotacione ao redor do eixo x, e translade ao longo do eixo z)

Olhe de volta no tutorial <<hello_node#,Hello Node>> se você não lembra os métodos de transformação para escalonar, transladar, e rotacionar.


link:http://jmonkeyengine.org/wiki/doku.php/jm3:solutions[http://jmonkeyengine.org/wiki/doku.php/jm3:solutions]
+++<u> Esteja certo de tentar resolvê-las por si só primeiro!</u>+++



== Conclusão

Agora você está ouvindo ao loop de atualização, “a batida do coração do jogo, e você pode adicionar todos os tipos de ação a ele.


A próxima coisa que o jogo precisa é alguma interação! Continue aprendendo a como <<jme3/beginner/hello_input_system-pt#, responder a entrada do usuário pt>>.

'''

Veja também:


*  Desenvolvedores jME3 avançados usam <<jme3/advanced/application_states#, Estados da Aplicação (Application States)>> e <<jme3/advanced/custom_controls#, Controles Personalizados (Custom Controls)>> para implementar mecânicas de jogo no loop de atualização deles. Você topará nestes tópicos de novo mais tarde quando você proceder para documentação mais avançada.
<tags><tag target="documentation" /><tag target="state" /><tag target="states" /><tag target="intro" /><tag target="beginner" /><tag target="control" /><tag target="loop" /></tags>