Como devo inserir a chave / mouse em um jogo java avançado?

Sou um programador autodidata, por isso não conheço as maneiras adequadas de fazer as coisas. Eu criei jogos simples como asteróides e cobra, mas nesses jogos, você pode modificar facilmente as variáveis ​​nas funções do evento principal. Aqui está como eu fiz isso no meu jogo simples de Asteróides:

/*
* key listener events
*/
public void keyReleased(KeyEvent k){
    int keyCode = k.getKeyCode();

    switch(keyCode){

        case KeyEvent.VK_LEFT:
            turnLeft = false;
            break;

        case KeyEvent.VK_RIGHT:
            turnRight = false;
            break;

        case KeyEvent.VK_UP:
            accel = false;
            break;

        case KeyEvent.VK_1:
            cls = true;
            break;
        case KeyEvent.VK_ENTER:
            break;
        case KeyEvent.VK_SPACE:
            fire = false;
    }
}
public void keyTyped(KeyEvent K){}
public void keyPressed(KeyEvent k){
    int keyCode = k.getKeyCode();

    switch(keyCode){

        case KeyEvent.VK_LEFT:
            turnLeft = true;
            break;

        case KeyEvent.VK_RIGHT:
            turnRight = true;
            break;

        case KeyEvent.VK_UP:
            accel = true;
            break;

        case KeyEvent.VK_1:
            cls = false;
            break;
        case KeyEvent.VK_ENTER:
            clearAllBullets();
            break;
        case KeyEvent.VK_SPACE:
            fire = true;
    }
}

Se eu fosse fazer um jogo mais avançado (com um menu principal, opções, jogo principal etc.), como devo fazer a entrada de tecla / mouse?

Além disso, se eu for para o modo single-player, devo colocar todo o código de jogo em uma classe? Existe uma maneira de colocar o código de jogador único em uma classe separada e, de alguma forma, a entrada de chave ainda modificar as variáveis ​​e tal?

Não sou especialista e, no entanto, sugiro separar os controles e a lógica de negócios / jogo / menu (nomeie isso).

Eu já respondi uma pergunta semelhante no que diz respeito a dar instruções para uma cobra em um jogo projetado com classes. Sendo Java uma linguagem orientada a objetos, acho que você é capaz de escrever classes e outras coisas adequadas. Então, quando você escrever sua classe de objeto, se for para que seu objeto precise reagir a algumas teclas e cliques do mouse, eu usaria uma classe Controller que sabe o que é exibido atualmente na tela e então diz a esse objeto o que deve faça dependendo da tecla que foi pressionada ou da região que foi clicada.

Aqui está o link para a pergunta que lhe contei sobre a qual respondi sobre a separação dos controles da lógica do objeto. Ele também inclui um exemplo de código que ilustra meu pensamento.

Movendo meu sprite no XNA usando classes

( Infelizmente, nenhuma das respostas ainda foi aceita pelo OP, por isso não sabemos ao certo se isso resolveu suas preocupações. Além disso, estou sempre desenhando dessa maneira e não encontrei problemas ao fazê-lo até agora. )

Agora eu sei, está marcado como XNA. A ideia ou o design é um nível de arquitetura mais alto do que a tecnologia usada, portanto, esse design pode ser simplesmente adaptado à sintaxe Java. A ideia geral permanece a mesma. =)

Eu espero que isso ajude! Ficarei feliz em ajudar ainda mais quando puder, basta perguntar! =)

A resposta de Will mostra o que é provavelmente o mais flexível e direto, e eu o recomendaria se você precisar de uma pesquisa de entrada direta.

Mas, se você precisar de uma maneira fácil de verificar diferentes combinações de pressionamentos de botão, evitando grandes quantidades de opções switch e if, use enumerações de sinalizadores de bits.

Não sei o que você sabe sobre vetores de bits, então aqui está uma visão geral: Basicamente, você tem uma classe enum que representa todas as chaves possíveis. Cada enumeração deve ter um valor que corresponda a um bit em um número inteiro. (ou seja: 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0011, 0x0012, 0x0014, etc.). ( Link para fazer isso em Java).

Agora, como você pode transmitir informações sobre até 32 (ou 64 se você usar longs) chaves, poderá ter uma tabela de hash que associa vetores de bits (int ou long) a objetos que caem em algum tipo de interface KeyComboCallback, que apenas contém um chamada de método único, Do (), que é chamada quando a combinação associada de teclas é pressionada.

Agora, quando você instancia / inicializa seu objeto player ou seu objeto de menu, você pode fazer uma chamada para algum tipo de gerenciador de entrada e passar todos os vetores de bits de combinação de teclas desejados e associá-los a classes internas anônimas.

// ... in your init code for Player

InputManager.map(
    KeyMap.A.val() | KeyMap.B.val() | KeyMap.C.val(), 
    new KeyComboCallback(KeyMap keys) {
        public void Do() {
           this.DoCrazyAwesomeComboAttack();
        }
    });

// ...  continue init

Isso é realmente rápido e conveniente em C ++ e C #, mas as enumerações de Java são especiais, portanto, é mais conveniente criar uma classe KeyCombination ou algo que armazene todas essas informações sem se preocupar com enumerações. Mas a ideia ainda é a mesma. Estou usando isso em um jogo XNA e gosto muito das instalações. Você também pode usá-lo para separar regiões de entrada, o que é útil para comparar diferentes partes do teclado ou do gamepad de forma independente (pode ser útil para dois jogadores em um teclado).