1. java
  2. android
  3. c#
  4. .net
  5. javascript
  6. php
  7. jquery
  8. html
  9. sql

Como esse HashMap recebe os valores dos ArrayList?

Estou fazendo um jogo para a faculdade e estou acompanhado os tutoriais do site abrindo o jogo quando me deparei com uma Classe que me confundiu bastante, a classe que chamei de Controle em meu projeto implementa a interface KeyListener e o que ela faz basicamente é receber os valores digitado no teclado e armazena-os em dois ArrayList um chamado pressedKeys que armazenas os botões pressionados e outro chamado releasedKey que armazena os valores dos botões que são liberados(soltos). Porem as ações que são desencadeadas com os códigos de desse botões só ocorrem de fato depois de passar os valores para um HashMap, local de onde são lidos e testados. A Classe funciona perfeitamente a questão é como e em que momento os valores contido nos arrays passam para o HashMap, é passado de alguma forma implícita ou algo do gênero?

package devryRacer;

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.ArrayList;
import java.util.HashMap;

//Padão de projeo Singleton
public class Controle implements KeyListener
{
    static protected int KEY_RELEASED = 0;
    static protected int KEY_JUST_PRESSED = 1;
    static protected int KEY_PRESSED = 2;
    static private Controle instance;
    private HashMap<Integer, Integer> keyCache;
    private ArrayList<Integer> pressedKeys;
    private ArrayList<Integer> releasedKeys;

    // Construtor só pode ser chamado por um metodo interno e so avera uma instancia dessa classe no pacote
    // afinal é um padrão singleton
    private Controle()
    {
        keyCache = new HashMap<Integer, Integer>();
        pressedKeys = new ArrayList<Integer>();
        releasedKeys = new ArrayList<Integer>();
    }

    // Método responsável por intancia o objeto Controle
    // se tiver uma instancia retorna ela, se não cria uma e retorna.
    static public Controle getInstance()
    {
        if (instance == null)
        {
            instance = new Controle();
        }
        return instance;
    }

    // Varifica se o botão foi segurado
    public boolean isPressed(int keyId)
    {
        return keyCache.containsKey(keyId)
                && !keyCache.get(keyId).equals(KEY_RELEASED);
    }

    // Verifica se o botão foi apenas pressionado e solto ligeiramente
    public boolean isJustPressed(int keyId)
    {
        return keyCache.containsKey(keyId)
                && keyCache.get(keyId).equals(KEY_JUST_PRESSED);
    }

    // Verifica se o botão foi solto
    public boolean isReleased(int keyId)
    {
        return !keyCache.containsKey(keyId)
                || keyCache.get(keyId).equals(KEY_RELEASED);
    }

    // Esse método é o primeiro a ser chamado no meu game loop, seguido do meu update(que atualiza as posições de imagem e variaveis) e 
    // render(que é reponsavel por desenhar na tela as imagens)
    /* 
     * Desta forma:
     * 
     * public void loop(){
        this.setIsRun(true);
        this.load();
        while(this.getIsRun()){
            Controle.getInstance().update();
            this.update(); //UPDATE PRINCIPAL
            this.render();
        }    
    }

    *Os metodos isPressed(), isReleased() e isJustPressed() são chamados no meu update principal desta forma:
    *
    *if(Controle.getInstance().isPressed(KeyEvent.VK_UP)) // verifica se esta presionado se sim acelera o carro.
            p1.acelera(); // p1 é um objeto da Classe Piloto que crei(off-topic).
    */

    public void update()
    {
        for (Integer keyCode : keyCache.keySet())
        {
            if (isJustPressed(keyCode))
            {
                keyCache.put(keyCode, KEY_PRESSED);
            }
        }
        for (Integer keyCode : releasedKeys)
        {
            keyCache.put(keyCode, KEY_RELEASED);
        }
        for (Integer keyCode : pressedKeys)
        {
            if (isReleased(keyCode))
            {
                keyCache.put(keyCode, KEY_JUST_PRESSED);
            } else
            {
                keyCache.put(keyCode, KEY_PRESSED);
            }
        }
        pressedKeys.clear();
        releasedKeys.clear();
    }

    public void keyTyped(KeyEvent e)
    {
        // Rotina não utilizada. Evento de tecla teclada.
    }

    public void keyPressed(KeyEvent e)
    {
        pressedKeys.add(e.getKeyCode());
    }

    public void keyReleased(KeyEvent e)
    {
        releasedKeys.add(e.getKeyCode());
    }
}
  1. Você vai ver essas setas em qualquer página de pergunta. Com elas, você pode dizer se uma pergunta ou uma resposta foram relevantes ou não.
  2. Edite sua pergunta ou resposta caso queira alterar ou adicionar detalhes.
  3. Caso haja alguma dúvida sobre a pergunta, adicione um comentário. O espaço de respostas deve ser utilizado apenas para responder a pergunta.
  4. Se o autor da pergunta marcar uma resposta como solucionada, esta marca aparecerá.
  5. Clique aqui para mais detalhes sobre o funcionamento do GUJ!

0 resposta

Não é a resposta que estava procurando? Procure outras perguntas com as tags java arraylist ou faça a sua própria pergunta.