Discussion :

[Ivelios]

Salutation,

j'essaie d'élaborer un jeu où un personnage se déplace à l'aide des flèches directionnels. J'utilise la méthode keypressed pour détecter l'appui sur les touches.

Mon problème est le suivant :

lorsque j'appuie sur la flèche droite (par exemple), mon personnage bouge.. puis il s'arrête pendant 1/2 sec... ensuite il "re" bouge mais cette fois ci sans s'arrêter.

Il se produit le même évènement sur les logiciels de traitement de texte lorsque l'on appuie sur une touche. (la lettre s'écrit, une pause, la lettre s'écrit en continu).

Ma question est la suivante :

Comment supprimer cette pause d'1/2 sec pour rendre le déplacement de mon personnage plus fluide?

Cordialement

[jojodu31]

Il se produit le même évènement sur les logiciels de traitement de texte lorsque l'on appuie sur une touche. (la lettre s'écrit, une pause, la lettre s'écrit en continu).

ça te le fais tt le tps ??
ça serait pas plus un pb de ton pc ?

[dinobogan]

Cela vient certainement de la manière de gérer tes événements clavier. Il n'y a aucune raison pour que ça réagisse ainsi

Si tu peux poster une partie du code, au moins la gestion des événements clavier, on y verrait un peu plus clair.

[Ivelios]

Gère les touches directionnels.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
	public void keyPressed(KeyEvent e) {
		switch(e.getKeyCode()){
	 		case KeyEvent.VK_LEFT:
	 			fenetre.PosXmoin();
	 			break;
	 		case KeyEvent.VK_RIGHT:
	 			fenetre.PosXplus();
	 			break;
	 		case KeyEvent.VK_UP:
	 			fenetre.PosYmoin();
	 			break;
	 		case KeyEvent.VK_DOWN:
	 			fenetre.PosYplus();
	 			break;			      
		}	
	}
 
	public void keyReleased(KeyEvent arg0) {}	
	public void keyTyped(KeyEvent arg0) {}
}

"fenetre" est une objet de la classe ci-dessous :

les méthodes ci-dessous permette de modifier les coordonnées de mon personnage. En modifiant x et y de 5px à chaque fois

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
public void PosXplus(){
        		x+=5;
        		pan.setPosX(x);
        		run();
        }
        public void PosXmoin(){
        		x-=5;
        		pan.setPosX(x);
        		run();
        }
        public void PosYplus(){
        		y+=5;
        		pan.setPosY(++y);
        		run();
        }
        public void PosYmoin(){
        		y-=5;
        		pan.setPosY(--y);
        		run();
        }
 
        private void run(){
            pan.repaint();
            try {
                    Thread.sleep(1);
            } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
            }       
        }

pan signifie panneau : il s'agit de la classe ci-dessous

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
 
private int posX = 0;
        private int posY = 0;
 
        public void paintComponent(Graphics g){
        	try{         
 
                //initialise la fenetre en la mettant toute blanche
                g.setColor(Color.white);
                g.fillRect(0, 0, this.getWidth(), this.getHeight());
 
                //dessine un cercle rouge,mon futur personnage
                g.setColor(Color.red);
                g.fillOval(posX, posY, 30, 30);  
 
        	}catch(Exception e ){System.out.println("problème");}
        }
 
        public int getPosX() {return posX;}
        public int getPosY() {return posY;}     
        public void setPosX(int posX) {this.posX = posX;}
        public void setPosY(int posY) {this.posY = posY;}

une classe gère les évènement des touches directionnel.
une classe modifie la position du personnage.
Et une classe qui dessine mon personnage.

[dinobogan]

Il faut utiliser conjointement un keyPressed et un keyReleased.

Un Thread doit toujours être "actif" et gérer les déplacements. Il se borne à faire une action de déplacement puis une petite pause. Une action sur une touche modifie un facteur de déplacement, utilisé par le Thread.

Ton implémentation utilise la répétition de touches gérée au niveau système, d'ou le problème de la demi seconde de pause.

[Ivelios]

Effectivement, j'ai cherché sur les différents forum une solution.
Ils disaient d'utiliser keyPressed mais aussi keyReleased.
En les liants avec un boolean par exemple.

Malheureusement je n'ai jamais réussi à faire fonctionner cette méthode.
C'est aussi dans cette optique que j'ai posté.

dinobogan, si tu pouvait me donner un exemple de ta méthode sa me serait très utile.

Cordialement

[dinobogan]

dinobogan, si tu pouvait me donner un exemple de ta méthode sa me serait très utile.

Ok, je vais détailler un peu plus ce que j'ai dit plus haut.
Il faut tout d'abord créer un Thread qui tourne en permanence. Ce Thread sera encapsulé dans la classe Deplacement. Il contient les variables de déplacement et les méthodes associées :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class Deplacement implements Runnable
{
  public enum DEPLACEMENT_X { GAUCHE, RIEN, DROITE };
  public enum DEPLACEMENT_Y { HAUT, RIEN, BAS };
  private DEPLACEMENT_X dx;
  private DEPLACEMENT_Y dy;
 
  public Deplacement()
  {
    ...
  }
 
  public void setDx( DEPLACEMENT_X dx ) { this.dx = dx; }
  public void setDy( DEPLACEMENT_Y dy ) { this.dy = dy; }
 
  public void run()
  {
    Thread current = Thread.currentThread();
    while( current == this )
    {
      if( dx == DEPLACEMENT_X.GAUCHE )
      {
        ...
      }
      else if( dx == DEPLACEMENT_X.DROITE )
      {
        ...
      }
 
      if( dy == DEPLACEMENT_X.HAUT )
      {
        ...
      }
      else if( dy == DEPLACEMENT_X.BAS )
      {
        ...
      }
 
      try { Thread.sleep( 500 ); }
      catch( InterruptedException exc ) {}
    }
  }
}

C'est donc lui qui va gérer tous les déplacements.
Ensuite, les actions sur les touches vont appeler les méthodes de modifications de direction du Thread :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class GestionKey implements KeyEvent
{
  ...
 
  public void keyPressed( KeyEvent event )
  {
    if( event.touche_du_haut )
    {
      instanceDeplacement.setDy( DEPLACEMENT_Y.HAUT );
    }
    else if( event.touche_de_gauche )
    {
      instanceDeplacement.setDx( DEPLACEMENT_X.GAUCHE );
    }
    else if ...
    ...
  }
 
  public void keyReleased( KeyEvent event )
  {
    if( event.touche_du_haut || event.touche_du_bas )
    {
      instanceDeplacement.setDy( DEPLACEMENT_Y.RIEN );
    }
    else ...
      ...
  }
}

Bien sûr, c'est uniquement du pseudo-code, je ne l'ai pas testé

[Ivelios]

plus d'un an passé... mais je me replanche sur le sujet
Merci dinobogan, ta méthode marche effectivement bien.
Mais j'ai malgré tous un problème. ça va commencer à ramer après 30 secondes.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class MonPanel extends JPanel {
 
    private Joueur joueur1, joueur2, joueur3, joueur4;
 
    public MonPanel(Fenetre frame) {
        super();
        this.setFocusable(true);
        this.requestFocus();
 
        joueur1 = new Joueur(this,1);
 
        EvenementClavier clavier = new EvenementClavier(joueur1;
        this.addKeyListener(clavier);
 
        new Thread(joueur1).start();
 
        this.repaint();
    }

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class EvenementClavier implements KeyListener{
 
    Joueur joueur1;
    public EvenementClavier(Joueur joueur1) {
        this.joueur1 = joueur1;
    }
 
 
    public void keyTyped(KeyEvent e) {}
    public void keyPressed(KeyEvent e) {
 
        int touche = e.getKeyCode();
 
        // gauche = 37 | haut = 38 | droite = 39 | bas = 40
        if(touche == 37){
            joueur1.setDx( DEPLACEMENT_X.GAUCHE );
        }else if(touche == 39){
            joueur1.setDx( DEPLACEMENT_X.DROITE );
        }
 
        if(touche == 38){
            joueur1.setDy( DEPLACEMENT_Y.HAUT );
 
 
        }else if(touche == 40){
            joueur1.setDy( DEPLACEMENT_Y.BAS );
 
        }
 
 public void keyReleased(KeyEvent e) {
        // gauche = 37 | haut = 38 | droite = 39 | bas = 40
       int touche = e.getKeyCode();
 
       if( (touche == 38 && joueur1.getDy() == DEPLACEMENT_Y.HAUT) || (touche == 40 && joueur1.getDy() == DEPLACEMENT_Y.BAS) ){
          joueur1.setDy( DEPLACEMENT_Y.RIEN );
 
       }else if( (touche == 37 && joueur1.getDx() == DEPLACEMENT_X.GAUCHE) || (touche == 39 && joueur1.getDx() == DEPLACEMENT_X.DROITE) ){
          joueur1.setDx( DEPLACEMENT_X.RIEN );
 
       }

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class Joueur implements Runnable{....
public void run() {
        while(true){
              if( dx == DEPLACEMENT_X.GAUCHE ){
                      for(int i =0;i<14;i++){
                          try {
                              Thread.sleep(10);
                              posX--;
                          }catch( InterruptedException exc ) {}
                      }
 
              }else if( dx == DEPLACEMENT_X.DROITE ){
                      for(int i =0;i<14;i++){
                          try {
                              Thread.sleep(10);
                              posX++;
                          }catch( InterruptedException exc ) {}
                      }
              }
 
              if( dy == DEPLACEMENT_Y.HAUT ){
                      for(int i =0;i<14;i++){
                          try {
                              Thread.sleep(10);
                              posY--;
                          }catch( InterruptedException exc ) {}
                      }
 
              } else if( dy == DEPLACEMENT_Y.BAS ){
                      for(int i =0;i<14;i++){
                          try {
                              Thread.sleep(10);
                              posY++;
                          }catch( InterruptedException exc ) {}
                      }
 
              }
 
 
            panel.repaint();
        }

Sa va ramer si j'ajoute un deuxième joueur et que je les déplacent en même temps. au lieu de faire un déplacement fluide de 14px, il vont se téléporter de 14px :s

[Ivelios]

en faite c'est bon. j'avais oublié de mettre des repaint() dans mes boucles de déplacement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 else if( dy == DEPLACEMENT_Y.BAS ){
                      for(int i =0;i<14;i++){
                          try {
                              Thread.sleep(10);
                              posY++;
                              panel.repaint();
                          }catch( InterruptedException exc ) {}
                      }
 
              }