Entrée de clé de jeu Java 2D (Meilleure pratique?)

Question

Je suis nouveau dans le développement de jeux et j'ai choisi de commencer à travailler sur un jeu de descente en 2D descendant. J'utilise la bibliothèque Slick2D pour ce jeu.

Ma question est sur les meilleures pratiques pour la prise multiple entrée de direction pour le mouvement de l'image-objet (UP + droite = diagonale)

Actuellement, j'ai un air assez laid si/elseif chaîne à lire dans l'entrée du clavier est ensuite vérifié dans la classe 'Mob' pour déterminer comment l'image-objet se déplacera. La configuration actuelle fonctionne très bien, mais ma question est de savoir s'il existe une autre meilleure façon de prendre plusieurs entrées pour les diagonales (ou n'importe quelle combinaison de touches, d'ailleurs)

Voici la méthode de mise à jour de la classe principale qui lit l'entrée (bêtisier est l'instance de « Mob »):

public void update(GameContainer container, StateBasedGame arg1, int delta) throws SlickException { 
    Input input = container.getInput(); 


    if(input.isKeyDown(Input.KEY_RIGHT)) {   //RIGHT 
     if(input.isKeyDown(Input.KEY_UP)){   //RIGHT + UP 
      blooper.direction = 2; 
     } else if(input.isKeyDown(Input.KEY_DOWN)){ //RIGHT + DOWN 
      blooper.direction = 3; 
     } 
     else { 
      blooper.direction = 1; 
     } 
    } else if(input.isKeyDown(Input.KEY_LEFT)){  //LEFT 
     if(input.isKeyDown(Input.KEY_UP)){   //LEFT + UP 
      blooper.direction = 5; 
     } else if(input.isKeyDown(Input.KEY_DOWN)){ //LEFT + DOWN 
      blooper.direction = 6; 
     } else{ 
      blooper.direction = 4; 
     } 
    } else if(input.isKeyDown(Input.KEY_UP)){  //UP 
     if(input.isKeyDown(Input.KEY_RIGHT)){  //UP + RIGHT 
      blooper.direction = 8; 
     } else if(input.isKeyDown(Input.KEY_LEFT)){ //UP + LEFT 
      blooper.direction = 9; 
     } else{ 
      blooper.direction = 7; 
     } 
    } else if(input.isKeyDown(Input.KEY_DOWN)){  //DOWN 
     if(input.isKeyDown(Input.KEY_RIGHT)){  //DOWN + RIGHT 
      blooper.direction = 11; 
     } else if(input.isKeyDown(Input.KEY_LEFT)){ //DOWN + LEFT 
      blooper.direction = 12; 
     } else{ 
      blooper.direction = 10; 
     } 
    } else{ 
     blooper.direction = -1; 
    } 

    blooper.update(delta); 

} 

Et voici comment cette entrée est traitée dans la classe Mob:

public class Mob { 

private final int RIGHT  = 1; 
private final int RIGHTUP = 2; 
private final int RIGHTDOWN = 3; 
private final int LEFT  = 4; 
private final int LEFTUP = 5; 
private final int LEFTDOWN = 6; 
private final int UP  = 7; 
private final int UPRIGHT = 8; 
private final int UPLEFT = 9; 
private final int DOWN  = 10; 
private final int DOWNRIGHT = 11; 
private final int DOWNLEFT = 12; 
private final int IDLE  = -1; 

int direction = IDLE; 

int x, y; 
Image sprite; 

public Mob() throws SlickException{ 
    x = 20; 
    y = 20; 
    sprite = new Image("res/blooper.png"); 
} 

public void update(int delta){ 
    move(); 
} 

public void draw(){ 
    sprite.draw(x, y); 
} 

public void move(){ 

    switch(direction){ 
     case RIGHT: 
      x += 1; 
      break; 
     case RIGHTUP: 
      x += 1; 
      y -= 1; 
      break; 
     case RIGHTDOWN: 
      x += 1; 
      y += 1; 
      break;   
     case LEFT: 
      x -= 1; 
      break; 
     case LEFTUP: 
      x -= 1; 
      y -= 1; 
      break; 
     case LEFTDOWN: 
      x -= 1; 
      y += 1; 
      break; 
     case UP: 
      y -= 1; 
      break; 
     case UPRIGHT: 
      y -= 1; 
      x += 1; 
      break; 
     case UPLEFT: 
      y -= 1; 
      x -= 1; 
      break; 
     case DOWN: 
      y += 1; 
      break; 
     case DOWNRIGHT: 
      y += 1; 
      x += 1; 
      break; 
     case DOWNLEFT: 
      y += 1; 
      x -= 1; 
      break; 
     case IDLE: 
      //nothing 
     } 
    } 
} 

Comme je l'ai dit ... cela fonctionne, mais ne semble pas être la meilleure façon de s'y prendre. Des conseils?

Answer 1

Indépendance des mouvements gauche/droite et haut/bas. Vous (ou le cadre - je ne suis pas familier avec lui) semble travailler avec des coordonnées x/y, qui sont mathématiquement indépendantes. Donc, faites une fonction qui traite le mouvement haut/bas, et une fonction qui traite le mouvement gauche/droite, et vous pouvez vous débarrasser de leurs «combinaisons». Y a-t-il une raison pour laquelle les directions sont des entiers positifs? Essayez de faire gauche = -1, droite = 1, et aucun mouvement de direction x 0, et faites de même pour y. Cela devrait le rendre plus intuitif.

Bonne codage

Answer 2

Faire un blooper.direction Bitwise, comme:

blooper.direction=0; 
if(input.isKeyDown(Input.KEY_RIGHT)) blooper.direction|=1; 
if(input.isKeyDown(Input.KEY_LEFT)) blooper.direction|=2; 
if(input.isKeyDown(Input.KEY_UP)) blooper.direction|=4; 
if(input.isKeyDown(Input.KEY_DOWN)) blooper.direction|=8; 

puis à move faire le mouvement, comme:

if ((blooper.direction&1)!=0) x+=1; 
if ((blooper.direction&2)!=0) x-=1; 
if ((blooper.direction&4)!=0) y-=1; 
if ((blooper.direction&8)!=0) y+=1;