Impossible de gérer avec le bug de mouvement dans le jeu Java.swing simple

Question

J'ai un problème avec le déplacement dans le jeu que je crée, tout fonctionne exactement comme je voudrais, sauf une chose, la carte est redessinée en fonction du délai de la minuterie et quand je fais plus d'un mouvement avant que la planche ne se redessine, alors il y a une chance que mon serpent tombe sur lui-même. Je ne peux pas gérer ça et je ne sais pas comment l'éviter, je pensais à régler un retard entre les boutons poussoirs mais c'est impossible car le jeu est pour deux joueurs. J'essaye d'empêcher de retourner le serpent sur lui-même. Quelqu'un peut-il m'aider à résoudre le problème? Merci.

Plusieurs photos représentant le problème:

gameplay normal:

Quand je les boutons anti-spam:

méthode Mouvement:

private void move() 
{ 

    for (int z = dots; z > 0; z--) 
    { 
     p1x[z] = p1x[(z - 1)]; 
     p1y[z] = p1y[(z - 1)]; 
     p2x[z] = p2x[(z - 1)]; 
     p2y[z] = p2y[(z - 1)]; 
    } 

    if (p1LeftDirection) 
    { 
     p1x[0] -= DOT_SIZE; 
    } 

    if (p1RightDirection) 
    { 
     p1x[0] += DOT_SIZE; 
    } 

    if (p1UpDirection) 
    { 
     p1y[0] -= DOT_SIZE; 
    } 

    if (p1DownDirection) 
    { 
     p1y[0] += DOT_SIZE; 
    } 

    if (p2LeftDirection) 
    { 
     p2x[0] -= DOT_SIZE; 
    } 

    if (p2RightDirection) 
    { 
     p2x[0] += DOT_SIZE; 
    } 

    if (p2UpDirection) 
    { 
     p2y[0] -= DOT_SIZE; 
    } 

    if (p2DownDirection) 
    { 
     p2y[0] += DOT_SIZE; 
    } 
    dots++; 
} 

méthode Dessin:

private void doDrawing(Graphics g) 
{ 
    if (inGame) 
    { 
     for (int z = 0; z < dots; z++) 
     { 
      if (z == 0) 
      { 
       g.drawImage(p1Head, p1x[z], p1y[z], this); 
       g.drawImage(p2Head, p2x[z], p2y[z], this); 
      } 
      else 
      { 
       g.drawImage(p1Body, p1x[z], p1y[z], this); 
       g.drawImage(p2Body, p2x[z], p2y[z], this); 
      } 
     } 

     for (int i = 0; i < B_WIDTH; i += 25) 
     { 
      g.drawImage(brick, 0, i, this); 
      g.drawImage(brick, i, 0, this); 
     } 
     for (int i = 0; i < B_WIDTH; i += 25) 
     { 
      g.drawImage(brick, B_WIDTH - DOT_SIZE, i, this); 
      g.drawImage(brick, i, B_HEIGHT - DOT_SIZE, this); 
     } 

     Toolkit.getDefaultToolkit().sync(); 
    } 
    else 
    { 
     gameOver(g); 
    } 
} 

Et mon KeyAdapter:

public class KeyboardSettings extends KeyAdapter 
{ 

    @Override 
    public void keyPressed(KeyEvent e) 
    { 
     int key = e.getKeyCode(); 

     if ((key == KeyEvent.VK_LEFT) && (!p1RightDirection)) 
     { 
      ImageIcon p1HeadLoader = new ImageIcon("src/main/resources/images/p1leftmouth.png"); 
      p1Head = p1HeadLoader.getImage(); 
      p1LeftDirection = true; 
      p1UpDirection = false; 
      p1DownDirection = false; 
     } 

     if ((key == KeyEvent.VK_RIGHT) && (!p1LeftDirection)) 
     { 
      ImageIcon p1HeadLoader = new ImageIcon("src/main/resources/images/p1rightmouth.png"); 
      p1Head = p1HeadLoader.getImage(); 
      p1RightDirection = true; 
      p1UpDirection = false; 
      p1DownDirection = false; 
     } 

     if ((key == KeyEvent.VK_UP) && (!p1DownDirection)) 
     { 
      ImageIcon p1HeadLoader = new ImageIcon("src/main/resources/images/p1upmouth.png"); 
      p1Head = p1HeadLoader.getImage(); 
      p1UpDirection = true; 
      p1RightDirection = false; 
      p1LeftDirection = false; 
     } 

     if ((key == KeyEvent.VK_DOWN) && (!p1UpDirection)) 
     { 
      ImageIcon p1HeadLoader = new ImageIcon("src/main/resources/images/p1downmouth.png"); 
      p1Head = p1HeadLoader.getImage(); 
      p1DownDirection = true; 
      p1RightDirection = false; 
      p1LeftDirection = false; 
     } 

     if ((key == KeyEvent.VK_A) && (!p2RightDirection)) 
     { 
      ImageIcon p2HeadLoader = new ImageIcon("src/main/resources/images/p2leftmouth.png"); 
      p2Head = p2HeadLoader.getImage(); 
      p2LeftDirection = true; 
      p2UpDirection = false; 
      p2DownDirection = false; 
     } 

     if ((key == KeyEvent.VK_D) && (!p2LeftDirection)) 
     { 
      ImageIcon p2HeadLoader = new ImageIcon("src/main/resources/images/p2rightmouth.png"); 
      p2Head = p2HeadLoader.getImage(); 
      p2RightDirection = true; 
      p2UpDirection = false; 
      p2DownDirection = false; 
     } 

     if ((key == KeyEvent.VK_W) && (!p2DownDirection)) 
     { 
      ImageIcon p2HeadLoader = new ImageIcon("src/main/resources/images/p2upmouth.png"); 
      p2Head = p2HeadLoader.getImage(); 
      p2UpDirection = true; 
      p2RightDirection = false; 
      p2LeftDirection = false; 
     } 

     if ((key == KeyEvent.VK_S) && (!p2UpDirection)) 
     { 
      ImageIcon p2HeadLoader = new ImageIcon("src/main/resources/images/p2downmouth.png"); 
      p2Head = p2HeadLoader.getImage(); 
      p2DownDirection = true; 
      p2RightDirection = false; 
      p2LeftDirection = false; 
     } 
    } 
} 

Answer 1

J'ai eu exactement le même problème. J'ai essayé différentes méthodes intégrées, mais elles n'ont pas fonctionné pour moi. Mais voici comment je contourner le problème avec ma méthode:

private void move() 
{ 

for (int z = dots; z > 0; z--) 
{ 
    p1x[z] = p1x[(z - 1)]; 
    p1y[z] = p1y[(z - 1)]; 
    p2x[z] = p2x[(z - 1)]; 
    p2y[z] = p2y[(z - 1)]; 
} 

if (p1LeftDirection) 
{ 
    p1x[0] -= DOT_SIZE; 
    if(p1x[0] == p1x[2]) 
    { 
     p1x[0] += 2*DOT_SIZE; 
     rotateCorr(); 
    } 
    else if(p1x[0] == p1x[1]) 
    { 
     p1x[0] += DOT_SIZE; 
     rotateCorr(); 
    } 
} 

if (p1RightDirection) 
{ 
    p1x[0] += DOT_SIZE; 
    if(p1x[0] == p1x[2]) 
    { 
     p1x[0] -= 2*DOT_SIZE; 
     rotateCorr(); 
    } 
    else if(p1x[0] == p1x[1]) 
    { 
     p1x[0] -= DOT_SIZE; 
     rotateCorr(); 
    } 
} 

if (p1UpDirection) 
{ 
    p1y[0] -= DOT_SIZE; 
    if(p1y[0] == p1y[2]) 
    { 
     p1y[0] += 2*DOT_SIZE; 
     rotateCorr(); 
    } 
    else if(p1y[0] == p1y[1]) 
    { 
     p1y[0] += DOT_SIZE; 
     rotateCorr(); 

    } 
} 

if (p1DownDirection) 
{ 
    p1y[0] += DOT_SIZE; 
    if(p1y[0] == p1y[2]) 
    { 
     p1y[0] -= 2*DOT_SIZE; 
     rotateCorr(); 
    } 
    else if(p1y[0] == p1y[1]) 
    { 
     p1y[0] -= DOT_SIZE; 
     rotateCorr(); 
    } 
} 

if (p2LeftDirection) 
{ 
    p2x[0] -= DOT_SIZE; 
    if(p2x[0] == p2x[2]) 
    { 
     p2x[0] += 2*DOT_SIZE; 
     rotateCorr(); 
    } 
    else if(p2x[0] == p2x[1]) 
    { 
     p2x[0] += DOT_SIZE; 
     rotateCorr(); 
    } 
} 

if (p2RightDirection) 
{ 
    p2x[0] += DOT_SIZE; 
    if(p2x[0] == p2x[2]) 
    { 
     p2x[0] -= 2*DOT_SIZE; 
     rotateCorr(); 
    } 
    else if(p2x[0] == p2x[1]) 
    { 
     p2x[0] -= DOT_SIZE; 
     rotateCorr(); 
    } 
} 

if (p2UpDirection) 
{ 
    p2y[0] -= DOT_SIZE; 
    if(p2y[0] == p2y[2]) 
    { 
     p2y[0] += 2*DOT_SIZE; 
     rotateCorr(); 
    } 
    else if(p2y[0] == p2y[1]) 
    { 
     p2y[0] += DOT_SIZE; 
     rotateCorr(); 
    } 
} 

if (p2DownDirection) 
{ 
    p2y[0] += DOT_SIZE; 
    if(p2y[0] == p2y[2]) 
    { 
     p2y[0] -= 2*DOT_SIZE; 
     rotateCorr(); 
    } 
    else if(p2y[0] == p2y[1]) 
    { 
     p2y[0] -= DOT_SIZE; 
     rotateCorr(); 
    } 
} 
dots++; 
} 

Je sais exactement le pépin vous avez fait face, donc cela devrait fonctionner pour vous. Fondamentalement, si plusieurs boutons sont pressés, le serpent revient sur lui-même, parce que d'abord il enregistre que la clé est valide, mais se déplace ensuite pour exécuter la clé invalide. Donc, même si logiquement, il fait NO FRIKKIN SENSE, les backtracks serpent. Ce code indique simplement que si le serpent recule (si la tête coïncide avec la première ou la deuxième partie du corps), alors la tête du serpent devrait revenir à son emplacement initial et reprendre sa direction initiale.

Code additionnel:

Pour tourner correctement la tête:

private void rotateCorr() 
{ 
    if(p1x[0] = p1x[1] - DOT_SIZE) 
    { 
      // Your code to rotate p1 head to face the left 
    } 
    if(p1x[0] = p1x[1] + DOT_SIZE) 
    { 
      // Your code to rotate p1 head to face the right 
    } 
    if(p1y[0] = p1y[1] - DOT_SIZE) 
    { 
      // Your code to rotate p1 head to face the top 
    } 
    if(p1y[0] = p1y[1] + DOT_SIZE) 
    { 
      // Your code to rotate p1 head to face the bottom 
    } 

    // Now, for p2 snake: 

    if(p2x[0] = p2x[1] - DOT_SIZE) 
    { 
      // Your code to rotate p2 head to face the left 
    } 
    if(p2x[0] = p2x[1] + DOT_SIZE) 
    { 
      // Your code to rotate p2 head to face the right 
    } 
    if(p2y[0] = p2y[1] - DOT_SIZE) 
    { 
      // Your code to rotate p2 head to face the top 
    } 
    if(p2y[0] = p2y[1] + DOT_SIZE) 
    { 
      // Your code to rotate p2 head to face the bottom 
    } 
} 

Si la tête est au-dessus de la seconde partie, il est tourné pour faire face à la partie supérieure, etc.