Problème de rapidité avec KeyListener et repaint()

Version imprimable

Bonjour,

Je cherche à faire bouger un personnage avec les touches droite/gauche du clavier. Ce personnage est une image et se situe dans un JPanel, pour cela j'utilise un keyListener et je modifie les coordonnée de l'image puis je repaint (cela fonctionne) mais mon problème est le suivant:

Soit je modifie les coordonnée de 1px par exemple pour chaque event du keylistener et le déplacement est trop lent
Soit je le déplace par 10-15px et la vitesse et meilleure mais c'est visuellement atroce (on voit les sacades, pas fluide du tout)

Est ce qu'il y aurait un moyen de déplacer rapidement l'image de manière fluide?

Voici mon code:

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
private class BananaGameView extends JPanel implements KeyListener {
 
		private BananaGameModel bananaGameModel;
		int x = 15;
		int y = 525;
		Image fond;
		Image character;
 
		public BananaGameView(BananaGameModel b) {
			super();
			bananaGameModel = b;	
 
			this.setLayout(null);
			this.setFocusable(true);
			this.requestFocusInWindow();
			this.addKeyListener(this);
 
			JButton back = new JButton();
			back.setIcon(new ImageIcon(this.getClass().getClassLoader().getResource("Pictures/BoutonBack.png" )));
			this.add(back);
			back.setBounds(670, 520, 110, 59);
			back.addActionListener(new ActionListener() {
				public void actionPerformed(ActionEvent e) { 
					MainWindow.gameOpened = false;
					MainWindow.gameWindow.dispose();
				}
			});			
 
			try {
				fond = ImageIO.read(this.getClass().getClassLoader().getResource("Pictures/Level.png"));
				character = ImageIO.read(this.getClass().getClassLoader().getResource("Pictures/Character.png"));
			} catch (IOException e) {
				e.printStackTrace();
			}
 
		}
 
		public void paintComponent(Graphics g){
			g.drawImage(fond, 0, 0, this);
			g.drawImage(character, x, y, this);
 
		}
 
		@Override
		public void keyPressed(KeyEvent e) {
			if (e.getKeyCode() == KeyEvent.VK_LEFT && x>=10) x-=15;
			else if(e.getKeyCode() == KeyEvent.VK_RIGHT && x<=715) x+=15;
			else if(e.getKeyCode() == KeyEvent.VK_SPACE) y-=15;
			repaint();
		}
// Problème ici: si je met 15 comme là c'est saccadé si je met 1 ou 2 c'est trop lent...
 
		@Override
		public void keyReleased(KeyEvent e) { }
 
		@Override
		public void keyTyped(KeyEvent e) { }
	}

Bonjour,

Il faut que tu utilises javax.swing.Timer pour redessiner ton image à intervalle fixe. En plus du pas d'incrementation (ici pas=1), le délai du timer (ici 5 milisecond) qui va te permettre d'aller plus ou moins vite.

dans ce timer tu appelles une méthode move() qui va mettre à jour les coordonnées et réafficher l'image.

ton keyListener va te servire à définir dx et dy(ex dx = -1) pour faire varier la direction. Et quand tu n'appuies pas sur une touche du définies dx =dy=0.

ainsi la méthode move se résume dans tous les cas à :

x = x + dx;
y = y + dy;

démonstration sur un exemple :

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
import java.awt.event.*;
import javax.swing.*;
import javax.swing.Timer;
import java.awt.*;
import javax.imageio.*;
import java.io.*;
import java.awt.image.*;
 
 
public class TestAnimation extends JPanel implements ActionListener
{
    private Timer timer;
    private BufferedImage image;
    private int x=0;
    private int y=0;
    private int dx,dy;
 
    public TestAnimation() 
    {
    	try {
    		image = ImageIO.read(new File("test.png"));	
    	}
    	catch(IOException e) {}
        addKeyListener(new TAdapter());
        setFocusable(true);
        setBackground(Color.BLACK);
        //setDoubleBuffered(true);
        timer = new Timer(5, this);
        timer.start();
    }
 
    public static void main(String[] args)
    {
        TestAnimation game = new TestAnimation();
 
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setLocationRelativeTo(null);
        f.setResizable(true);
        f.setSize(640, 480);
        f.add(game);
        f.setVisible(true);
 
    }
 
    @Override
    public void paint(Graphics g) 
    {
        super.paint(g);
 
        Graphics2D g2d = (Graphics2D)g;
        g2d.drawImage(image, x, y, this);
        repaint();
        //Toolkit.getDefaultToolkit().sync();
        g.dispose();
    }
 
 
    @Override
    public void actionPerformed(ActionEvent e) 
    {
        move();
        repaint();  
    }
 
    private class TAdapter extends KeyAdapter 
    {
 
        @Override
        public void keyReleased(KeyEvent e) {
            int key = e.getKeyCode();
 
            if (key == KeyEvent.VK_LEFT) {
            	    dx = 0;
            }
 
            if (key == KeyEvent.VK_RIGHT) {
            	    dx = 0;
            }
 
            if (key == KeyEvent.VK_UP) {
            	    dy = 0;
            }
 
            if (key == KeyEvent.VK_DOWN) {
            	    dy = 0;
            }
        }
 
        @Override
        public void keyPressed(KeyEvent e) {
            int key = e.getKeyCode();
 
            if (key == KeyEvent.VK_LEFT) {
            	    dx = -1;
            }
 
            if (key == KeyEvent.VK_RIGHT) {
            	    dx = 1;
            }
 
            if (key == KeyEvent.VK_UP) {
            	    dy = -1;
            }
 
            if (key == KeyEvent.VK_DOWN) {
            	    dy = 1;
            }
        }
    }
 public void move() {
        x += dx;
        y += dy;
    }
}

14/06/2013, 14h56
Epiliptik

Merci ça marche nickel, en fait la méthode actionPerformed se déclenche à chaque tic du timer si j'ai bien compris?
14/06/2013, 18h40
ludomacho

bonjour,

oui c'est cela. Le Timer de javax.swing utilise actionPerformed pour decrire l'action à accomplir toutes les n millisecondes.