KeyPressed : supprimer la pause

Version imprimable

04/07/2008, 13h12
Ivelios

KeyPressed : supprimer la pause

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. :cry:

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
04/07/2008, 14h12
jojodu31

Citation:

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 ?? 8O
ça serait pas plus un pb de ton pc ?
04/07/2008, 14h22
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 :roll:

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

code

Gère les touches directionnels.

Code:

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:

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:

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.

04/07/2008, 14h39
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.
04/07/2008, 18h45
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

Citation:

Envoyé par Ivelios

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:

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:

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é ;)

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:

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:

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:

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

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

Code:

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 ) {}
                      }
 
              }