= jMonkeyEngine 3 Tutorial (4) - Hello Update Loop
:author: 
:revnumber: 
:revdate: 2016/03/17 20:48
:keywords: documentation, state, states, intro, beginner, control, loop
:relfileprefix: ../../
:imagesdir: ../..
ifdef::env-github,env-browser[:outfilesuffix: .adoc]


Anterior: <<jme3/beginner/hello_asset-pt#, Hello Assets pt>>,
Next: <<jme3/beginner/hello_input_system-pt#, Hello Input System pt>>

Agora que você sabe como carregar ativos, como modelos 3D, você quer implementar alguma jogabilidade que usa estes ativos. Neste tutorial nós olhamos no loop de atualização. O loop de atualização de seu jogo é onde a ação acontece.


== Amostra de Código

[source,java]
----

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)`.


[TIP]
====
Tudo em um jogo acontece ou durante a inicialização ou durante o loop de atualização. Isto significa que estes dois métodos crescem muito com o tempo. Há duas estratégias como desenvolvedores experientes espalham o código de atualização e inicialização em várias classes Java:

*  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>>.

mantenha isto em mente pata depois quando sua aplicação crescer.

====



== 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 <<jme3/beginner/hello_node#,Hello Node>> se você não lembra os métodos de transformação para escalonar, transladar, e rotacionar.


[IMPORTANT]
====
Link para soluções propostas pelos usuário: <<jm3/solutions#,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.
