Problème d'initialisation d'un KeyEvent

Version imprimable

Donc cela fait plusieurs semaines que je suis bloqué sur quelque chose de normalement simple. Je ne sais pas comment initialiser mon KeyEvent, je reçois Exception in thread "AWT-EventQueue-0" java.lang.NullPointerException ceci.

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
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.KeyEvent; 
import java.awt.event.KeyAdapter;
 
public class PriseDeTouches extends KeyAdapter {
 
    KeyEvent dep;
    boolean gauche;
    boolean haut;
    boolean droit; 
    boolean bas;
 
 
    public void PriseDeTouches(){        
        keyPressed(dep);
        keyReleased(dep);
    }
 
    @Override
    public void keyPressed(KeyEvent arg0) {
        System.out.println("fonction presse +1");
        int keycode = arg0.getKeyCode();
        switch(keycode){
            case KeyEvent.VK_UP :
                haut = true; 
                System.out.println("Touche haut +1");
                setHaut(haut);
                getHaut();
            case KeyEvent.VK_LEFT :
                gauche = true;
                System.out.println("Touche gauche +1");
                setGauche(gauche);
                getGauche();
            case KeyEvent.VK_RIGHT :
                droit = true;
                System.out.println("Touche droite +1");
                setDroit(droit);
                getDroit();
            case KeyEvent.VK_DOWN :
                bas = true;
                System.out.println("Touche bas +1");
                setBas(bas);
                getBas();
            default : 
                break;
        } 
    }        
 
 
 
    @Override
    public void keyReleased(KeyEvent arg0) {
        System.out.println("fonction presse -1");
        int keycode = arg0.getKeyCode();
        switch(keycode){
            case KeyEvent.VK_UP :
                haut = false; 
                System.out.println("Touche haut -1");
                setHaut(haut);
                getHaut();
            case KeyEvent.VK_LEFT :
                gauche = false;
                System.out.println("Touche gauche -1");
                setGauche(gauche);
                getGauche();
            case KeyEvent.VK_RIGHT :
                droit = false;
                System.out.println("Touche droite -1");
                setDroit(droit);
                getDroit();
            case KeyEvent.VK_DOWN :
                bas = false;
                System.out.println("Touche bas -1");
                setBas(bas);
                getBas();
            default :    
                break;
        }
    }
    public boolean getHaut(){
        return haut;
    }
 
    public boolean getBas(){
        return bas;
    }
 
    public boolean getGauche(){
        return gauche;
    }
 
    public boolean getDroit(){
        return droit;
    }
 
    public void setHaut(boolean haut){
        this.haut = haut;
    }
 
    public void setBas(boolean bas){
        this.bas = bas;
    }
 
    public void setGauche(boolean gauche){
        this.gauche = gauche;
    }
 
    public void setDroit(boolean droit){
        this.droit = droit;
    }   
 
    @Override
    public void keyTyped(KeyEvent ke) {
 
    }
}

Du coup si quelqu'un peut m'aider, j'ai déjà essayer beaucoup de solutions mais peut-être que je les faisais mal.

Salut,

Un KeyListener est prévu pour écouter (listener=écouteur) les évenements sur un composant donné.

Exemple, tiré de la FAQ :
Code:

1 2 3 4 monTextField.addKeyListener(new KeyAdapter() { public void keyTyped(KeyEvent e) { } });
Quel est le composant source que tu voudrais écouter ?

En fonction du besoin, tu peux également utiliser un KeyEventDispatcher, qui te permettra d'écouter globalement dans ton interface graphique les évenements clavier, sans écouter un composant en particulier (écoute les composants qui ont le focus) :
Code:

1 2 3 4 5 6 7 8 KeyboardFocusManager manager = KeyboardFocusManager.getCurrentKeyboardFocusManager(); manager.addKeyEventDispatcher(new KeyEventDispatcher() { public boolean dispatchKeyEvent(KeyEvent e) { ... } }
Dans les 2 cas, tu n'as pas a générer les instances de KeyEvent : c'est SWING qui s'en chargera.

16/11/2014, 22h07
Parasoul

Ok, dans mon cas je vais plutôt utilisé le KeyEventDispatcher car je souhaite récupérer mes entrées clavier mais aussi des entrée souris que je n'ai pas encore codé, si j'ai bien compris j'aurai juste à donné le focus à l'un ou à l'autre par la suite. Je ne vois pas comment placer le KeyEventDispatcher dans mon code. Je vais continuer de chercher avec ce que tu m'a donné, merci.
17/11/2014, 01h53
joel.drigo
Tu peux le faire par exemple tout simple au début de ton programme (dans la méthode main(), ou la méthode qui affiche ta fenêtre (JFrame) principale).

Des discussions avec exemples :
- http://www.developpez.net/forums/d14...e/#post7922494
- http://www.developpez.net/forums/d14...n/#post8015546

Merci bien pour cette aide, je récupère bien les entrées clavier maintenant donc voici mon code refait :

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
package props.fall;
 
import java.awt.KeyEventDispatcher;
import java.awt.KeyboardFocusManager;
import java.awt.event.KeyEvent;
import java.util.logging.Level;
import java.util.logging.Logger;
 
 
public class Deplacement {
 
    public int posXPersonnage;
    public int posYPersonnage;
 
        KeyEventDispatcher keyEventDispatcher = new KeyEventDispatcher() {
	@Override
            public boolean dispatchKeyEvent(KeyEvent e) {
                                System.out.println("+2");
                                int posXPersonnage = getPosXPersonnage();                          
                                int posYPersonnage = getPosYPersonnage();
                                setPosXPersonnage(posXPersonnage);
				try {switch (e.getKeyCode()) {
				case KeyEvent.VK_UP:
					posXPersonnage = posXPersonnage - 4;
                                        setPosXPersonnage(posXPersonnage);
                                        getPosXPersonnage();
					break;
				case KeyEvent.VK_DOWN:
                                        posYPersonnage = posYPersonnage - 4;
                                        setPosYPersonnage(posYPersonnage);
                                        getPosYPersonnage();					
					break;
				case KeyEvent.VK_RIGHT:
					posXPersonnage = posXPersonnage + 4;
                                        setPosXPersonnage(posXPersonnage);
                                        getPosXPersonnage();
					break;
				case KeyEvent.VK_LEFT:
					posYPersonnage = posYPersonnage + 4;
                                        setPosYPersonnage(posYPersonnage);
                                        getPosYPersonnage();
					break;
                                }
                                Thread.sleep(5);
        } 
        catch (InterruptedException ex) {
                    Logger.getLogger(Deplacement.class.getName()).log(Level.SEVERE, null, ex);
        }
                                return false;
            }
 
        };
KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(keyEventDispatcher);
 
    }
 
    public void setPosXPersonnage(int posXPersonnage){
        this.posXPersonnage = posXPersonnage;
    }
 
    public void setPosYPersonnage(int posYPersonnage){
        this.posYPersonnage = posYPersonnage;
    }
 
    public int getPosXPersonnage(){
        return posXPersonnage;
    }
 
    public int getPosYPersonnage(){
        return posYPersonnage;
    }
}

Le problème que j'ai maintenant c'est que je ne ressors plus de la boucle. Si j'appuie sur une touche je rentre dans mon switch pour touche du haut, puis je sors plus de mon dispatch.
Et mes get/set ne marche plus, (je peux trouver seul ça normalement, ça doit venir du fait que je ne sors plus de ma boucle).

Ton code n'est pas complet, là... C'est surtout le KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(keyEventDispatcher); qui m'intrigue, parce que là, on voit pas bien où il se trouve exactement (ça compile pas) : j'espère qu'il n'est pas dans la méthode dispatchKeyEvent(), sinon ça veut dire à chaque appui de touche va ajouter un même KeyEventDispatcher, qui fait la même chose, du coup ton personnage, va se déplacer une fois de plus à chaque appui (tu appuies, il se déplace de 4, puis tu rappuies, il se déplace de 2x4=8, puis 12, 16...)

De quelle boucle parle-tu ? Parce que dans ce bout de code, je ne vois aucune boucle.

Par ailleurs, c'est quoi ce sleep ? Les évènements SWING, comme ceux du clavier en l’occurrence, sont exécutés dans l'Event Dispatch Thread (le thread des SWING, qui sert également à gérer l'affichage) : donc ce sleep bloque SWING, pas longtemps certes, mais il ne faut jamais faire ça.

Les appels aux getters que tu fais dans le switch ne servent strictement à rien (le getter retourne une valeur que tu ne récupères même pas dans une variable, alors en faire quelque chose...). Le premier setPOSXPersonnage() en dehors du switch ne sert à rien, sauf à perdre du temps (posXPersonnnage n'a pas été modifié depuis le get).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 int posXPersonnage = getPosXPersonnage(); int posYPersonnage = getPosYPersonnage(); try {switch (e.getKeyCode()) { case KeyEvent.VK_UP: posXPersonnage = posXPersonnage - 4; // ou posXPersonnage -= 4; break; case KeyEvent.VK_DOWN: posYPersonnage = posYPersonnage - 4; break; case KeyEvent.VK_RIGHT: posXPersonnage = posXPersonnage + 4; break; case KeyEvent.VK_LEFT: posYPersonnage = posYPersonnage + 4; break; } setPosXPersonnage(posXPersonnage); setPosYPersonnage(posYPersonnage);

C'est comme ceci que je devrait le faire du coup? Et je me suis trompé sur mon terme de boucle je voulait dire la fonction, mais le problème viens du pc sur lequel je suis qui rame.

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
KeyboardFocusManager manager = KeyboardFocusManager.getCurrentKeyboardFocusManager();
        manager.addKeyEventDispatcher(new KeyEventDispatcher(){
            @Override
            public boolean dispatchKeyEvent(KeyEvent e) {
                int posXPersonnage = getPosXPersonnage();                          
                int posYPersonnage = getPosYPersonnage();
 
                switch (e.getKeyCode()) {
                    case KeyEvent.VK_UP:
                        posXPersonnage -= 4;
                        break;
                    case KeyEvent.VK_DOWN:
                        posYPersonnage -= 4;	
                        break;
                    case KeyEvent.VK_RIGHT:
                        posXPersonnage += 4;
                        break;
                    case KeyEvent.VK_LEFT:
                        posYPersonnage += 4;
                        break;
                }
                setPosXPersonnage(posXPersonnage);
                setPosYPersonnage(posYPersonnage);
                return false;
            }                                       
        });

Tu parles de la méthode dispatchKeyEvent() ?. C'est normal qu'elle soit appelée plusieurs fois : elle l'est à chaque appui de touche du clavier.

Voici un exemple de démonstration :

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
117
118
public class DemoDeplacement extends JPanel {
 
	public final static int DEPLACEMENT = 4; 
	public final static int SIZE = 8;
 
	public static void main(String[] args) {
 
		SwingUtilities.invokeLater( ()->demo( new DemoDeplacement() ) );
 
	}
 
	private static void demo( final DemoDeplacement demoDeplacement ) {
		final JFrame frame = new JFrame( "Démo" );
		frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
		frame.setSize( 300, 300 );
		frame.setLocationRelativeTo( null );
		frame.getContentPane().add( demoDeplacement );
 
		KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(
				(e) -> { 
                                              if( e.getID()==KeyEvent.KEY_PRESSED ) {
							switch(e.getKeyCode()) {
							case KeyEvent.VK_DOWN:
								demoDeplacement.deplacer(0, DEPLACEMENT);
								return true; 
							case KeyEvent.VK_UP:
								demoDeplacement.deplacer(0, -DEPLACEMENT);
								return true;
							case KeyEvent.VK_RIGHT:
								demoDeplacement.deplacer(DEPLACEMENT, 0);
								return true;
							case KeyEvent.VK_LEFT:
								demoDeplacement.deplacer(-DEPLACEMENT, 0);
								return true;
							}
						}
						return false;
					} );
 
		demoDeplacement.addComponentListener( new ComponentAdapter() {
			@Override
			public void componentResized( ComponentEvent e ) {
				demoDeplacement.replacer();
			}
		});
 
		frame.setVisible(true);
 
	}
 
	private int x=0;
	private int y=0; 
 
	public DemoDeplacement() {
		setBackground( Color.GREEN.darker() );
	}
 
	@Override
	public void paint( final Graphics g ) {
		super.paint( g );
		final Graphics2D graphics = (Graphics2D)g.create();
		try {
			graphics.setColor( Color.ORANGE );
			graphics.setRenderingHint( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON );
			graphics.fillOval( x, y, SIZE, SIZE ); 
		}
		finally {
			graphics.dispose();
		}
	}
 
	public void deplacer( final int dx, final int dy ) {
		final int oldx = x;
		x = deplace( x, dx, getWidth() - SIZE );
		final int oldy = y;
		y = deplace( y, dy, getHeight() - SIZE );
		if ( oldx != x || oldy != y ) {
			repaint();
		}
	}
 
	private int deplace( int c, final int dc, final int maxc ) {
		if ( dc < 0 && c > 0 ) {
			c += dc;
			if ( c < 0 ) {
				c = 0;
			}
		}
		else if ( dc>0 && c<maxc ) {
			c += dc;
			if ( c > maxc ) {
				c = maxc;
			}
		}
		return c;
	}
 
	public void replacer() {
		final int oldx = x;
		x = replace( x, getWidth() - SIZE );
		final int oldy = y;
		y = replace( y, getHeight() - SIZE );
		if ( oldx != x || oldy != y ) {
			repaint();
		}
	}
 
	private int replace( int c, final int maxc ) {
			if ( c < 0 ) {
				c = 0;
			}
			else if ( c > maxc ) {
				c = maxc;
			}
			return c;
	}
 
}

[EDIT] : je viens de comprendre ton problème : la méthode est bien appelée 2 fois pour chaque touche. Une première fois pour l'évenement KeyEvent.KEY_PRESSED, une seconde fois pour l'évènement KeyEvent.KEY_RELEASED. Il faut effectivement tester le type qui t'intéresse (l'action de déplacement est-elle faite lorsqu'on presse la touche, ou quand on la relâche ?).

Je voudrais faire déplacer mon personnage quand je reste appuyé sur ma touche donc je dois appeler keyPressed pour lancer le déplacement et keyReleased pour l’arrêter du coup.

[EDIT]

Du coup mon code avec le deux fonctions doit ressembler à ceci :

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
public class Deplacement {
 
    public int posXPersonnage;
    public int posYPersonnage;
 
 
    public void DeplacementPersonnage(int posXPersonnage,int posYPersonnage){
 
        setPosYPersonnage(posYPersonnage);
        setPosXPersonnage(posXPersonnage);
 
        KeyboardFocusManager manager = KeyboardFocusManager.getCurrentKeyboardFocusManager();
        manager.addKeyEventDispatcher(new KeyEventDispatcher(){
            @Override
            public boolean dispatchKeyEvent(KeyEvent e) {
                int posXPersonnage = getPosXPersonnage();                          
                int posYPersonnage = getPosYPersonnage();
                boolean haut = false;
                boolean bas = false;
                boolean droit = false;
                boolean gauche = false;
 
                if( e.getID()==KeyEvent.KEY_PRESSED ) {
                    switch (e.getKeyCode()) {
                        case KeyEvent.VK_UP:
                            haut = true;                              
                            break;
                        case KeyEvent.VK_DOWN:
                            bas = true;	
                            break;
                        case KeyEvent.VK_RIGHT:
                            droit = true;
                            break;
                        case KeyEvent.VK_LEFT:
                            gauche = true;
                            break;
                        default:
                            break;
                    }
                }  
                if( e.getID()==KeyEvent.KEY_RELEASED ) {
                    switch (e.getKeyCode()) {
                        case KeyEvent.VK_UP:
                            haut = false;
                            break;
                        case KeyEvent.VK_DOWN:
                            bas = false;	
                            break;
                        case KeyEvent.VK_RIGHT:
                            droit = false;
                            break;
                        case KeyEvent.VK_LEFT:
                            gauche = false;
                            break;
                        default:
                            break;
                    }
                }
                if(haut){
                    posXPersonnage -= 4;
                }
                if(bas){
                    posXPersonnage += 4;
                }
                if(droit){
                    posYPersonnage -= 4;
                }
                if(gauche){
                    posYPersonnage += 4;
                }
 
                setPosXPersonnage(posXPersonnage);
                setPosYPersonnage(posYPersonnage);
                return false;
            }                                                       
        });
 
 
    }
 
    public void setPosXPersonnage(int posXPersonnage){
        this.posXPersonnage = posXPersonnage;
    }
 
    public void setPosYPersonnage(int posYPersonnage){
        this.posYPersonnage = posYPersonnage;
    }
 
    public int getPosXPersonnage(){
        return posXPersonnage;
    }
 
    public int getPosYPersonnage(){
        return posYPersonnage;
    }
}

J'ai mis ceci dans ma classe appelant la méthode :
deplacement.DeplacementPersonnage(posXPersonnage, posYPersonnage);
posXPersonnage = deplacement.posXPersonnage;
posYPersonnage = deplacement.posYPersonnage;
mais ça ne récupère pas la valeur transformé.

Pas besoin de gérer l'arrêt, si tu fais comme dans mon exemple.

la différence pour le choix entre PRESSED ou RELEASE est importante également pour la dynamique :

avec PRESSED, le personnage va se déplacer tant que la touche est enfoncée, et s'arrête dès que la touche est lachée (avec un défaut : si on appui sur une autre touche de déplacement dans relâcher la première, et qu'on relâche la seconde, il n'y aura plus d'évènement pour correspondre à l'appui de la première, et donc le personnage s'arrêtera. Ce serait plus complexe à gérer : il faudrait un thread (ou un générateur d'événement (timer)), une gestion d'état et une sorte de mini-pseudo-pile, pour connaitre l'ordre d'appui des touches, pour gérer les touches opposées). C'est pareil si on veut pouvoir faire des déplacements en diagonale, où on peut appuyer ou relâcher une touche quand on veut (donc avoir 2 touches appuyées en même temps).
avec RELEASED, le personnage ne pourra se déplacer que par acoup : il faudra relâcher la touche et la ré appuyer pour faire un nouveau mouvement.

[EDIT] Oups, j'avais pas vu que tu avais modifié ton message :
en fait, tu ne peux pas faire comme tu fais : tes variables haut, bas, droite et gauche sont locales à la méthode, donc elles sont pas mémorisées entre chaque appel : donc toutes la partie que tu fais sur le pressed ne sert à rien. En plus, là ça donne l'impression qu'on peut combiner les mouvements, pour faire de la diagonale, mais tu ne peux pas faire ça comme ça non plus.

On pourrait avoir une approche comme ça en utilisant une classe déportée qui mémorise les haut, bas, droite, gauche entre chaque appels, comme suit (j'ai mis un début d'approche pour empêcher les touches contradictoire). Mais ça ne résoudrait pas le problème de la fin des évenements qui suit un RELEASE. Si tu testes cet exemple, tu verras, que si tu fais droite, puis haut, tu iras en diagonal, mais dès que tu relâches haut, sans relâcher droite, ça s'arrête.

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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
public class DemoDeplacement extends JPanel {
 
	public final static int DEPLACEMENT = 4; 
	public final static int SIZE = 8;
 
	public static void main(String[] args) {
 
		SwingUtilities.invokeLater( ()->demo( new DemoDeplacement() ) );
 
	}
 
	private static void demo( final DemoDeplacement demoDeplacement ) {
		final JFrame frame = new JFrame( "Démo" );
		frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
		frame.setSize( 300, 300 );
		frame.setLocationRelativeTo( null );
		frame.getContentPane().add( demoDeplacement );
 
 
		KeyHandler handler = new KeyHandler();
		KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(
				(e) ->  { 
					        boolean consumed = false;
							switch(e.getKeyCode()) {
							case KeyEvent.VK_DOWN:
								if( e.getID()==KeyEvent.KEY_PRESSED ) { 
									handler.pushDown( );
								}
								else {
									handler.popDown( );
								}
								consumed = true; 
								break;
							case KeyEvent.VK_UP:
								if( e.getID()==KeyEvent.KEY_PRESSED ) { 
									handler.pushUp( );
								}
								else {
									handler.popUp( );
								}
								consumed = true; 
								break;
							case KeyEvent.VK_RIGHT:
								if( e.getID()==KeyEvent.KEY_PRESSED ) { 
									handler.pushRight( );
								}
								else {
									handler.popRight( );
								}
								consumed = true;
								break;
							case KeyEvent.VK_LEFT:
								if( e.getID()==KeyEvent.KEY_PRESSED ) { 
									handler.pushLeft( );
								}
								else {
									handler.popLeft( );
								}
								consumed = true;
								break;
							} 
						if ( consumed ) {
							demoDeplacement.deplacer(handler.getDeplacementX(), handler.getDeplacementY());
						}
						return consumed;
					}
					);
 
		demoDeplacement.addComponentListener( new ComponentAdapter() {
			@Override
			public void componentResized( ComponentEvent e ) {
				demoDeplacement.replacer();
			}
		});
 
		frame.setVisible(true);
 
	}
 
	private int x=0;
	private int y=0; 
 
	public DemoDeplacement() {
		setBackground( Color.GREEN.darker() );
	}
 
	@Override
	public void paint( final Graphics g ) {
		super.paint( g );
		final Graphics2D graphics = (Graphics2D)g.create();
		try {
			graphics.setColor( Color.ORANGE );
			graphics.setRenderingHint( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON );
			graphics.fillOval( x, y, SIZE, SIZE ); 
		}
		finally {
			graphics.dispose();
		}
	}
 
	public void deplacer( final int dx, final int dy ) {
		final int oldx = x;
		x = deplace( x, dx, getWidth() - SIZE );
		final int oldy = y;
		y = deplace( y, dy, getHeight() - SIZE );
		if ( oldx != x || oldy != y ) {
			repaint();
		}
	}
 
	private int deplace( int c, final int dc, final int maxc ) {
		if ( dc < 0 && c > 0 ) {
			c += dc;
			if ( c < 0 ) {
				c = 0;
			}
		}
		else if ( dc>0 && c<maxc ) {
			c += dc;
			if ( c > maxc ) {
				c = maxc;
			}
		}
		return c;
	}
 
	public void replacer() {
		final int oldx = x;
		x = replace( x, getWidth() - SIZE );
		final int oldy = y;
		y = replace( y, getHeight() - SIZE );
		if ( oldx != x || oldy != y ) {
			repaint();
		}
	}
 
	private int replace( int c, final int maxc ) {
			if ( c < 0 ) {
				c = 0;
			}
			else if ( c > maxc ) {
				c = maxc;
			}
			return c;
	}
 
	private static final class KeyHandler {
 
		public enum DIR {
			UP,
			DOWN,
			LEFT,
			RIGHT,
			NONE
		}
 
		private int dx;
		private int dy;
 
		private boolean up;
		private boolean down;
		private DIR updown = DIR.NONE;
		private boolean right;
		private boolean left;
		private DIR rightleft= DIR.NONE;
 
 
		public void pushRight() {
			right=true;
			if ( rightleft==DIR.NONE ) {
				rightleft=DIR.RIGHT;
			}
			update();
		}
 
		public void popRight() {
			right=false;
			if ( rightleft==DIR.RIGHT ) {
				if ( left ) {
					rightleft=DIR.LEFT;
				}
				else {
					rightleft=DIR.NONE;
				}
			}
			update();
		}
 
		public void pushLeft() {
			left=true;
			if ( rightleft==DIR.NONE ) {
				rightleft=DIR.LEFT;
			}
			update();
		}
 
		public void popLeft() {
			left=false;
			if ( rightleft==DIR.LEFT ) {
				if ( right ) {
					rightleft=DIR.RIGHT;
				}
				else {
					rightleft=DIR.NONE;
				}
			}
			update();
		}
 
		public void pushUp() {
			up=true;
			if ( updown==DIR.NONE ) {
				updown=DIR.UP;
			}
			update();
		}
 
		public void popUp() {
			up=false;
			if ( updown==DIR.UP) {
				if ( down ) {
					updown=DIR.DOWN;
				}
				else {
					updown=DIR.NONE;
				}
			}
			update();
		}
 
		public void pushDown() {
			down=true;
			if ( updown==DIR.NONE ) {
				updown=DIR.DOWN;
			}
			update();
		}
 
		public void popDown() {
			down=false;
			if ( updown==DIR.DOWN ) {
				if ( up ) {
					updown=DIR.UP;
				}
				else {
					updown=DIR.NONE;
				}
			}
			update();
		}
 
		private void update() {
			switch(rightleft) {
			case NONE:
				dx=0;
				break;
			case LEFT:
				if ( left ) dx=-DEPLACEMENT;
				else dx=0;
				break;
			case RIGHT:
				if ( right ) dx=DEPLACEMENT;
				else dx=0;
				break;
			default:
				break;
			}
			switch(updown) {
			case NONE:
				dy=0;
				break;
			case UP:
				if ( up ) dy=-DEPLACEMENT;
				else dy=0;
				break;
			case DOWN:
				if ( down ) dy=DEPLACEMENT;
				else dy=0;
				break;
			default:
				break;
			}
		}
 
 
		public int getDeplacementX() {
			return dx;
		}
 
		public int getDeplacementY() {
			return dy;
		}
 
	}
 
}

17/11/2014, 17h17
Parasoul

Ok je vais voir pour ta première méthode du coup (timer, gestion d'état + mini-pseudo-pile), mais avant j'aimerais savoir du coup pour récupérer la variable dans mon autre classe(demandé poste précédent), ce sera plus facile pour moi ensuite de vérifier mon code.
17/11/2014, 17h35
joel.drigo
Citation:

Envoyé par Parasoul

Ok je vais voir pour ta première méthode du coup (timer, gestion d'état + mini-pseudo-pile), mais avant j'aimerais savoir du coup pour récupérer la variable dans mon autre classe(demandé poste précédent), ce sera plus facile pour moi ensuite de vérifier mon code.

Tu parles de ce code :
Code:

1 2 3 deplacement.DeplacementPersonnage(posXPersonnage, posYPersonnage); posXPersonnage = deplacement.posXPersonnage; posYPersonnage = deplacement.posYPersonnage;
La première ligne initialise les coordonnées dans la classe Deplacement, et ça en enregistre un KeyEventDispatcher. Puis ça met dans 2 variables les valeurs de 2 autres variables de la classe Deplacement (pour lesquelles tu as fait des getter, donc pourquoi les faire public ?).

Je suppose que ces 2 variables sont les coordonnées de ton personnage. Ces variables doivent être modifiées quand l'évènement arrive. Tu ne peux pas à un endroit dans le code dire que une variable égale une autre, et s'attendre à ce que la première soit toujours égale à la seconde. L'opérateur égal n'a rien à voir avec une assertion mathématique : c'est un opérateur d'affectation.
Code:

1 2 3 int a=1; int b=a; a=2;
A la fin de code b vaut 1, pas 2 ! Parce qu'au moment où b=a a été exécuté, a valait 1.

Si lorsque tu dessines ton personnage (au moment du Paint), tu fais toujours référence aux variables (en appelant deplacement.getPosXPersonnage et deplacement.getPosYPersonnage) qui sont dans ta classe Deplacement, ça fonctionnera.

Et n'appelle qu'une seule fois deplacement.DeplacementPersonnage(posXPersonnage, posYPersonnage), au début. Sinon tu auras autant de KeyEventDispatcher qui écoutent que d'appels. En fait, tu ne devrais pas faire le addKeyEventDispatcher() dans cette méthode : tu rends dépendant d'une problématique d'évènement clavier, une classe qui est là pour gérer des coordonnées, et des déplacements. Il ne devrait pas y avoir de dépendance dans ce sens.
17/11/2014, 17h52
Parasoul

Merci bien, donc j'arrive à le déplacer mais comme tu l'a dit :

Citation:

Et n'appelle qu'une seule fois deplacement.DeplacementPersonnage(posXPersonnage, posYPersonnage), au début. Sinon tu auras autant de KeyEventDispatcher qui écoutent que d'appels. En fait, tu ne devrais pas faire le addKeyEventDispatcher() dans cette méthode : tu rends dépendant d'une problématique d'évènement clavier, une classe qui est là pour gérer des coordonnées, et des déplacements. Il ne devrait pas y avoir de dépendance dans ce sens.

Ça me créé plusieurs keyEventDispatcher, mais dans quel méthode dois-je l'appeler du coup?
17/11/2014, 17h58
joel.drigo

Regarde le(s) code(s) que je t'ai mis.

Voilà la démo pour la version avec timer :

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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
public class DemoDeplacement extends JPanel {
 
	public final static int DEPLACEMENT = 4; 
	public final static int SIZE = 8;
	// si OPPOSITE_NOT_ALLOWED=true : permet d'indiquer que si 2 touches opposées sont enfoncées en même temps, il n'y a pas de mouvement
	// si OPPOSITE_NOT_ALLOWED=false : c'est le premier mouvemeent qui fait si 2 touches opposées sont enfoncées en même temps
	private static final boolean OPPOSITE_NOT_ALLOWED = true;
 
	public static void main(String[] args) {
 
		SwingUtilities.invokeLater( ()->demo( new DemoDeplacement(OPPOSITE_NOT_ALLOWED) ) );
 
	}
 
	private static void demo( final DemoDeplacement demoDeplacement ) {
		final JFrame frame = new JFrame( "Démo" );
		frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
		frame.setSize( 300, 300 );
		frame.setLocationRelativeTo( null );
		frame.getContentPane().add( demoDeplacement );
 
 
		KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(
				(e) ->  { return demoDeplacement.getKeyStateHandler().dispatch(e); } );
 
		demoDeplacement.addComponentListener( new ComponentAdapter() {
			@Override
			public void componentResized( ComponentEvent e ) {
				demoDeplacement.replacer();
			}
		});
 
		frame.addWindowListener(new WindowAdapter() {
			private Timer timer;
			@Override
			public void windowOpened(WindowEvent e) {
				timer = new Timer();
				timer.schedule(new TimerTask() {
 
					@Override
					public void run() {
						demoDeplacement.deplacer();
					}
				}, 0, 40);
			}
			@Override
			public void windowClosed(WindowEvent e) {
				 timer.cancel();
			}
		});
		frame.setVisible(true);
 
	}
 
	private int x=0;
	private int y=0; 
	private final KeyStateHandler handler;
 
	public DemoDeplacement(boolean oppositeNotAllowed) {
		setBackground( Color.GREEN.darker() );
		handler = new KeyStateHandler(oppositeNotAllowed);
	}
 
	public KeyStateHandler getKeyStateHandler() {
		return handler;
	}
 
	@Override
	public void paint( final Graphics g ) {
		super.paint( g );
		final Graphics2D graphics = (Graphics2D)g.create();
		try {
			graphics.setColor( Color.ORANGE );
			graphics.setRenderingHint( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON );
			graphics.fillOval( x, y, SIZE, SIZE ); 
		}
		finally {
			graphics.dispose();
		}
	}
 
	public void deplacer() {
		SwingUtilities.invokeLater( ()-> deplacer( handler.getDeplacementX(), handler.getDeplacementY() ) );
	}
 
	public void deplacer( final int dx, final int dy ) {
		final int oldx = x;
		x = deplace( x, dx, getWidth() - SIZE );
		final int oldy = y;
		y = deplace( y, dy, getHeight() - SIZE );
		if ( oldx != x || oldy != y ) {
			repaint();
		}
	}
 
	private int deplace( int c, final int dc, final int maxc ) {
		if ( dc < 0 && c > 0 ) {
			c += dc;
			if ( c < 0 ) {
				c = 0;
			}
		}
		else if ( dc>0 && c<maxc ) {
			c += dc;
			if ( c > maxc ) {
				c = maxc;
			}
		}
		return c;
	}
 
	public void replacer() {
		final int oldx = x;
		x = replace( x, getWidth() - SIZE );
		final int oldy = y;
		y = replace( y, getHeight() - SIZE );
		if ( oldx != x || oldy != y ) {
			repaint();
		}
	}
 
	private int replace( int c, final int maxc ) {
			if ( c < 0 ) {
				c = 0;
			}
			else if ( c > maxc ) {
				c = maxc;
			}
			return c;
	}
 
	private static class KeyStateHandler {
 
		public enum Direction {
			DOWN,
			UP,
			LEFT,
			RIGHT,
			NONE;
		}
 
		private final Direction[] keyX;
		private final Direction[] keyY;
		private final boolean oppositeNotAllowed;
 
		public KeyStateHandler(boolean oppositeNotAllowed) {
			this.oppositeNotAllowed=oppositeNotAllowed;
			keyX = new Direction[2];
			Arrays.fill(keyX, Direction.NONE);
			keyY = new Direction[2];
			Arrays.fill(keyY, Direction.NONE);
		}
 
		public boolean dispatch(KeyEvent e) {
			boolean consumed;
			switch (e.getID()) {
			case KeyEvent.KEY_PRESSED:
				consumed = pressed(e.getKeyCode());
				break;
			case KeyEvent.KEY_RELEASED:
				consumed = released(e.getKeyCode());
				break;
			default:
				consumed = false;
				break;
			}
			return consumed;
		}
 
		private boolean pressed(int keyCode) {
			Direction[] dirStack;
			Direction dir;
			switch (keyCode) {
			case KeyEvent.VK_DOWN:
				dir = Direction.DOWN;
				dirStack = keyY;
				break;
			case KeyEvent.VK_UP:
				dir = Direction.UP;
				dirStack = keyY;
				break;
			case KeyEvent.VK_LEFT:
				dir = Direction.LEFT;
				dirStack = keyX;
				break;
			case KeyEvent.VK_RIGHT:
				dir = Direction.RIGHT;
				dirStack = keyX;
				break;
			default:
				dir = null;
				dirStack = null;
				break;
			}
			if ( dirStack!=null ) {
				if ( dirStack[0]!=dir ) {
					if ( dirStack[0]==Direction.NONE ) {
						dirStack[0]=dir;
					}
					else {
						dirStack[1]=dir;
					}
				}
				return true;
			}
			return false;
		}
 
		private boolean released(int keyCode) {
			Direction[] dirStack;
			Direction dir;
			switch (keyCode) {
			case KeyEvent.VK_DOWN:
				dir = Direction.DOWN;
				dirStack = keyY;
				break;
			case KeyEvent.VK_UP:
				dir = Direction.UP;
				dirStack = keyY;
				break;
			case KeyEvent.VK_LEFT:
				dir = Direction.LEFT;
				dirStack = keyX;
				break;
			case KeyEvent.VK_RIGHT:
				dir = Direction.RIGHT;
				dirStack = keyX;
				break;
			default:
				dir = null;
				dirStack = null;
				break;
			}
			if ( dirStack!=null ) {
				if ( dirStack[0]==dir ) {
					dirStack[0]=dirStack[1];
					dirStack[1]=Direction.NONE;
				}
				else if ( dirStack[1]==dir ) {
					dirStack[1]=Direction.NONE;
				}
				return true;
			}
			return false;
		}
 
		public int getDeplacementX() {
			int dx;
			if ( oppositeNotAllowed && keyX[1]!=Direction.NONE ) {
				dx=0;
			}
			else {
				switch( keyX[0] ) {
				case LEFT:
					dx=-DEPLACEMENT;
					break;
				case RIGHT:
					dx=DEPLACEMENT;
					break;
				default:
					dx=0;
					break;
				}
			}
			return dx;
		}
 
		public int getDeplacementY() {
			int dy;
			if ( oppositeNotAllowed && keyY[1]!=Direction.NONE ) {
				dy=0;
			}
			else {
				switch( keyY[0] ) {
				case UP:
					dy=-DEPLACEMENT;
					break;
				case DOWN:
					dy=DEPLACEMENT;
					break;
				default:
					dy=0;
					break;
				}
			}
			return dy;
		}
 
	}
 
}

Merci encore, je vais continuer à chercher et je te tiens au courant d'où j'en suis rendu. Par contre pour la démo j'ai pas mal de message d'erreur que je ne saurais résoudre (je travaille sous NetBeans, pour info)

Donc voici ton code avec les messages d'erreur noté en commentaire.

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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.KeyboardFocusManager;
import java.awt.RenderingHints;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.Arrays;
import java.util.TimerTask;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.Timer;
 
public class DemoDeplacement extends JPanel {
 
	public final static int DEPLACEMENT = 4; 
	public final static int SIZE = 8;
	private static final boolean OPPOSITE_NOT_ALLOWED = true;
 
	public static void main(String[] args) {
 
		SwingUtilities.invokeLater( ()->demo( new DemoDeplacement(OPPOSITE_NOT_ALLOWED) ) );
                //illegal start of expression, 'void' not allowed
	}
 
	private static void demo( final DemoDeplacement demoDeplacement ) {
		final JFrame frame = new JFrame( "Démo" );
		frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
		frame.setSize( 300, 300 );
		frame.setLocationRelativeTo( null );
		frame.getContentPane().add( demoDeplacement );
 
 
		KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(
				(e) ->  { return demoDeplacement.getKeyStateHandler().dispatch(e); } );
                                //illegal start of expression x 3, cannot find symbol -> e, illegal start of type
                                //cannot return a value from method whose result type is void, cannot find symbol -> e
 
		demoDeplacement.addComponentListener( new ComponentAdapter() {
			@Override
			public void componentResized( ComponentEvent e ) {
				demoDeplacement.replacer();
			}
		});
 
		frame.addWindowListener(new WindowAdapter() {
			private Timer timer;
			@Override
			public void windowOpened(WindowEvent e) {
				timer = new Timer();
                                //constructor timer cannot be applied to given type, required: int,ActionListener
                                //found : no arguments
 
				timer.schedule(new TimerTask() {
                                    //cannot find symbol -> method schedule (<anonymous TimerTask,int,int)
 
					@Override
					public void run() {
						demoDeplacement.deplacer();
					}
				}, 0, 40);
			}
			@Override
			public void windowClosed(WindowEvent e) {
				 timer.cancel();
                                 //cannot find symbol -> method cancel()
			}
		});
		frame.setVisible(true);
 
	}
 
	private int x=0;
	private int y=0; 
	private final KeyStateHandler handler;
 
	public DemoDeplacement(boolean oppositeNotAllowed) {
		setBackground( Color.GREEN.darker() );
		handler = new KeyStateHandler(oppositeNotAllowed);
	}
 
	public KeyStateHandler getKeyStateHandler() {
                               //Exporting non-public type through public API (souligné en jaune)
		return handler;
	}
 
	@Override
	public void paint( final Graphics g ) {
		super.paint( g );
		final Graphics2D graphics = (Graphics2D)g.create();
		try {
			graphics.setColor( Color.ORANGE );
			graphics.setRenderingHint( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON );
			graphics.fillOval( x, y, SIZE, SIZE ); 
		}
		finally {
			graphics.dispose();
		}
	}
 
	public void deplacer() {
		SwingUtilities.invokeLater( ()-> deplacer( handler.getDeplacementX(), handler.getDeplacementY() ) );
                //illegal start of expression x2 ,'void' type not allowed here
	}
 
	public void deplacer( final int dx, final int dy ) {
		final int oldx = x;
		x = deplace( x, dx, getWidth() - SIZE );
		final int oldy = y;
		y = deplace( y, dy, getHeight() - SIZE );
		if ( oldx != x || oldy != y ) {
			repaint();
		}
	}
 
	private int deplace( int c, final int dc, final int maxc ) {
		if ( dc < 0 && c > 0 ) {
			c += dc;
			if ( c < 0 ) {
				c = 0;
			}
		}
		else if ( dc>0 && c<maxc ) {
			c += dc;
			if ( c > maxc ) {
				c = maxc;
			}
		}
		return c;
	}
 
	public void replacer() {
		final int oldx = x;
		x = replace( x, getWidth() - SIZE );
		final int oldy = y;
		y = replace( y, getHeight() - SIZE );
		if ( oldx != x || oldy != y ) {
			repaint();
		}
	}
 
	private int replace( int c, final int maxc ) {
			if ( c < 0 ) {
				c = 0;
			}
			else if ( c > maxc ) {
				c = maxc;
			}
			return c;
	}
 
	private static class KeyStateHandler {
 
		public enum Direction {
			DOWN,
			UP,
			LEFT,
			RIGHT,
			NONE;
		}
 
		private final Direction[] keyX;
		private final Direction[] keyY;
		private final boolean oppositeNotAllowed;
 
		public KeyStateHandler(boolean oppositeNotAllowed) {
			this.oppositeNotAllowed=oppositeNotAllowed;
			keyX = new Direction[2];
			Arrays.fill(keyX, Direction.NONE);
			keyY = new Direction[2];
			Arrays.fill(keyY, Direction.NONE);
		}
 
		public boolean dispatch(KeyEvent e) {
			boolean consumed;
			switch (e.getID()) {
			case KeyEvent.KEY_PRESSED:
				consumed = pressed(e.getKeyCode());
				break;
			case KeyEvent.KEY_RELEASED:
				consumed = released(e.getKeyCode());
				break;
			default:
				consumed = false;
				break;
			}
			return consumed;
		}
 
		private boolean pressed(int keyCode) {
			Direction[] dirStack;
			Direction dir;
			switch (keyCode) {
			case KeyEvent.VK_DOWN:
				dir = Direction.DOWN;
				dirStack = keyY;
				break;
			case KeyEvent.VK_UP:
				dir = Direction.UP;
				dirStack = keyY;
				break;
			case KeyEvent.VK_LEFT:
				dir = Direction.LEFT;
				dirStack = keyX;
				break;
			case KeyEvent.VK_RIGHT:
				dir = Direction.RIGHT;
				dirStack = keyX;
				break;
			default:
				dir = null;
				dirStack = null;
				break;
			}
			if ( dirStack!=null ) {
				if ( dirStack[0]!=dir ) {
					if ( dirStack[0]==Direction.NONE ) {
						dirStack[0]=dir;
					}
					else {
						dirStack[1]=dir;
					}
				}
				return true;
			}
			return false;
		}
 
		private boolean released(int keyCode) {
			Direction[] dirStack;
			Direction dir;
			switch (keyCode) {
			case KeyEvent.VK_DOWN:
				dir = Direction.DOWN;
				dirStack = keyY;
				break;
			case KeyEvent.VK_UP:
				dir = Direction.UP;
				dirStack = keyY;
				break;
			case KeyEvent.VK_LEFT:
				dir = Direction.LEFT;
				dirStack = keyX;
				break;
			case KeyEvent.VK_RIGHT:
				dir = Direction.RIGHT;
				dirStack = keyX;
				break;
			default:
				dir = null;
				dirStack = null;
				break;
			}
			if ( dirStack!=null ) {
				if ( dirStack[0]==dir ) {
					dirStack[0]=dirStack[1];
					dirStack[1]=Direction.NONE;
				}
				else if ( dirStack[1]==dir ) {
					dirStack[1]=Direction.NONE;
				}
				return true;
			}
			return false;
		}
 
		public int getDeplacementX() {
			int dx;
			if ( oppositeNotAllowed && keyX[1]!=Direction.NONE ) {
				dx=0;
			}
			else {
				switch( keyX[0] ) {
				case LEFT:
					dx=-DEPLACEMENT;
					break;
				case RIGHT:
					dx=DEPLACEMENT;
					break;
				default:
					dx=0;
					break;
				}
			}
			return dx;
		}
 
		public int getDeplacementY() {
			int dy;
			if ( oppositeNotAllowed && keyY[1]!=Direction.NONE ) {
				dy=0;
			}
			else {
				switch( keyY[0] ) {
				case UP:
					dy=-DEPLACEMENT;
					break;
				case DOWN:
					dy=DEPLACEMENT;
					break;
				default:
					dy=0;
					break;
				}
			}
			return dy;
		}
	} 
}

18/11/2014, 11h14
joel.drigo
Ça n'a rien à voir avec le fait que tu travailles sous NetBeans (heureusement que l'IDE ne change pas la syntaxe du langage Java (!)), mais avec le fait que tu travailles avec une version de Java antérieure à Java 8.

Les erreurs concernent des expressions "lambda". Pour "convertir" les expressions lambda, qui sont sous la forme ( quelquechose ou pas ) -> expression (ou bloc), il te suffit de d'utiliser la complétion pour voir le type attendu du paramètre de la méthode correspondant, puis de remplacer l'expression lambda par new cetype : là, normalement, ton IDE va te créer automatiquement le code de la classe anonyme, et en particulier une méthode. Tu n'as plus qu'à mettre dans cette méthode l'expression (ou bloc) derrière le ->.

Par exemple :

Code:

SwingUtilities.invokeLater( ()->demo( new DemoDeplacement(OPPOSITE_NOT_ALLOWED) ) );

devient
Code:

1 2 3 4 5 6 7 SwingUtilities.invokeLater( new Runnable() { public void run() { demo( new DemoDeplacement(OPPOSITE_NOT_ALLOWED) ); } });
Pour Timer, tu as dû importer javax.swing.TImer au lieu de java.util.Timer.

Pour la méthode getKeyStateHandler(), effectivement pour une utilisation dans un contexte général, il faudrait que la classe soit déclarée public (cela dit c'est juste un warning) :

Code:

public static class KeyStateHandler {

Pour le coup, si je devais utiliser cette classe de démo dans un contexte général, je m'arrangerais différemment pour que la classe ne soit pas visible (protected), mais avec une interface visible, où, au moins avec un constructeur privé. Mais c'est une autre histoire...

ok, juste à la ligne 38, je vois comment faire, en suivant ce que tu m'a dit j'obtiens ceci :

Code:

1
2
3
4
5
KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(
                                new Runnable(e){                                   
                                    public void run() {
                                       return demoDeplacement.getKeyStateHandler().dispatch(e);
                                    }});

mais c'est faux.

18/11/2014, 11h40
joel.drigo

Non, tu n'as pas fais

Citation:

il te suffit de d'utiliser la complétion pour voir le type attendu du paramètre de la méthode correspondant

. J'ai jamais dit qu'il fallait utiliser la classe Runnable systématiquement.

Dans ce cas la classe attendue, c'est KeyEventDispatcher...

Je vois pas quoi faire après ceci :

Code:

1
2
3
4
5
6
 
		KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(
                                new KeyEventDispatcher(e){                                       
                                    public KeyStateHandler run() {
                                       return demoDeplacement.getKeyStateHandler().dispatch(e);
                                    }

Euh, on parle de KeyEventDispatcher depuis 17 posts.

Code:

1
2
3
4
5
6
7
8
9
KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(
   new KeyEventDispatcher() {
 
       @Override
       public boolean dispatchKeyEvent(KeyEvent e) {
	    return demoDeplacement.getKeyStateHandler().dispatch(e);
       }
 
});

Tout simplement.

J'ai refait des recherches et j'ai réussit à faire ce que je voulais sans faire des trucs aussi compliqué que ce que tu m'a donné, ce n'est surement pas aussi optimisé mais voici mon code :

mon KeyboardListener :

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
package props.fall;
 
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
 
 
public class KeyboardListener extends KeyAdapter {
        Panneau panneau; 
 
        public KeyboardListener(Panneau panneau) {
            this.panneau = panneau;
        }
 
 
        @Override
        public void keyPressed(KeyEvent event) {
 
             int keycode = event.getKeyCode();                         
             switch (keycode) {
                    case KeyEvent.VK_LEFT:
                        panneau.DeplacementGauche1();
                        break;
                    case KeyEvent.VK_RIGHT:
                        panneau.DeplacementDroit1();
                        break;
                    case KeyEvent.VK_DOWN:
                        panneau.DeplacementBas1();
                        break;
                    case KeyEvent.VK_UP:
                        panneau.DeplacementHaut1();
                        break;
                    default:                 
                        break;
             }
       }
 
        @Override
        public void keyReleased(KeyEvent event) {
 
             int keycode = event.getKeyCode();                        
             switch (keycode) {
                    case KeyEvent.VK_LEFT:
                        panneau.DeplacementGauche0();                       
                        break;
                    case KeyEvent.VK_RIGHT:
                        panneau.DeplacementDroit0();
                        break;
                    case KeyEvent.VK_DOWN:
                        panneau.DeplacementBas0();
                        break;
                    case KeyEvent.VK_UP:
                        panneau.DeplacementHaut0();
                        break;
                    default:                 
                        break;
             }
       }
}

et le code l'utilisant :

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
package props.fall;
 
 
import java.awt.Graphics;
import javax.swing.JPanel;
 
public class Panneau extends JPanel { 
    private int posXPersonnage;
    private int posYPersonnage;
    private int posXCaisse;
    private int posYCaisse;
    private int height;
    private int width;
    private int i = 0;
    private final Personnage pers = new Personnage();
    private final MurSol mursol = new MurSol();
    private final Fond fond = new Fond();
    private final Caisse caisse = new Caisse();
    private final KeyboardListener keyboardlistener = new KeyboardListener(this);
    boolean haut = false, bas = false, droit = false, gauche = false;
 
 
    @Override
    public void paintComponent(Graphics g){      
        setFocusable(true);
        if (i == 0){
            addKeyListener(keyboardlistener);
            i++;
        }
        if (posXPersonnage == 0 && posYPersonnage == 0){
            posXPersonnage = this.getWidth() / 2;
            posYPersonnage = this.getHeight() /2;
        }
 
 
        height = this.getHeight();
        width = this.getWidth();
        posXCaisse = 200;
        posYCaisse = 200;
        movement();
        fond.PaintFond(g, width, height);
        pers.PaintPersonnage(g, posXPersonnage, posYPersonnage);
        mursol.PaintMurSol(g, width, height);
        caisse.PaintCaisse(g, posXCaisse, posYCaisse);
        repaint();            
    }
 
    public void movement(){
        while (haut){
            posYPersonnage -= 5;
            break;
        }
        while (bas){
            posYPersonnage += 5;
            break;
        }
        while (droit){
            posXPersonnage += 5;
            break;
        }
        while (gauche){
            posXPersonnage -= 5;
            break;
        }
    }
 
    public void DeplacementHaut1(){
        haut = true;               
    }
 
    public void DeplacementBas1(){
        bas = true;               
    }
 
    public void DeplacementDroit1(){
        droit = true;              
    }
 
    public void DeplacementGauche1(){
        gauche = true;              
    }
 
    public void DeplacementHaut0(){
        haut = false;              
    }
 
    public void DeplacementBas0(){
        bas = false;                
    }
 
    public void DeplacementDroit0(){
        droit = false;               
    }
 
    public void DeplacementGauche0(){
        gauche = false;                
    }
}

Et il me permet de me déplacer en diagonale, ce que tu me disais impossible avec cette méthode.

20/11/2014, 12h14
joel.drigo

J'ai jamais dit que c'était impossible : j'ai dit qu'il y avait un défaut, quand on lâchait une touche alors qu'on en avait appuyée deux de sens opposés (j'ai d'ailleurs donnée une solution qui fonctionnait me semble-t-il). Parce qu'il n'y avait plus d'évènement à partir de ce moment, problème que j'ai compensé par l'introduction d'un Timer.( D'ailleurs ton programme à ce défaut aussi. Alors, c'est sûr normalement, personne ne devrait faire haut/bas en même temps, ou droite/gauche en même temps, mais ça arrive sans arrêt que des utilisateurs fassent ce qu'on devrait pas. Cela dit, j'ai donné un exemple, qui avait ce défaut, et qui fonctionnait, et qui n'avait rien de plus compliqué que le tiens.)

Toi tu as compensé le défaut par une des plus mauvaise pratique qui soit : appeler repaint() dans la méthode paint() (paintComponent() en fait, mais c'est pareil). Donc en fait, ton programme redessine continuellement le panel, inutilement, et en consommant du cpu pour rien. Peut-être que ça fonctionnne avec ton test, sur ta machine, avec le peu de choses que tu dessines, mais ça ne sera pas forcément toujours le cas. Et encore sur la mienne, qui est un peu puissante, j'ai pas le temps de voir le personnage se déplacer. Il est instantanément hors de la fenêtre (ou alors il faut que je passe les coordonnées en double, et utiliser un incrément de 0.1d, qu'il faudra ajuster, en fonction de ce qu'on affiche, et de la vitesse de la machine), donc pour moi, ce programme ne fonctionne pas.
La méthode paint() doit faire le minimum de choses, et uniquement ce qui concerne le dessin : rendre focusable un composant n'a aucun sens dans cette méthode, tout comme y enregistrer un écouteur d'évènement.
Et je ne vois nullepart dans ton code le bornage du déplacement de ton personnage. Et pourquoi le centrer s'il est au point haut-gauche : chaque fois qu'on revient à ce point, il revient au centre (c'est peut-être voulu remarque).

Je cherchais à donner une solution propre, nette, pérenne et qui puisse être étendue, sans tout réadapter.

Si tu veux négliger le défaut des touches opposées, soit, ta solution fonctionne (avec variable à état mais sans pseudo pile), mais remplace le repaint() par un Timer : comme-ça déjà tu contrôle le temps entre 2 positions, indépendamment de tout le reste (donc la vitesse de déplacement ne dépend ni de la machine, ni de ce qui y tourne, ni de ce que tu dessines), fait le repaint() quand c'est nécessaire.

Dans mon programme, si j'appuie que gauche et droit en même temps, mon personnage s'arrête, puis si je relâche une touche par exemple gauche il ira à droite, (mais je ne peux pas sauter lorsque gauche et droit sont enfoncé, seul défault qui ne me gène pas), donc je trouve ça logique et ça me convient. Ensuite le recentrage était pour résoudre un problème que j'avais, mais plus ici, je le change donc. Le bornage et autre n'étaient pas encore fait. pour le plus gros soucis, le repaint() ^^, je savais pas comment m'y prendre merci pour le Timer, mais je vois pas où le placer et comment il va redessiner à la place du repaint : je remet mon code complet (jusqu'au main).

Main :

Code:

1
2
3
4
5
6
7
8
9
10
package props.fall;
 
 
public class PropsFall {
 
    public static void main(String[] args) {
      new Fenetre();
 
    }
}

Ma fenetre :

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
package props.fall;
 
 
import javax.swing.JFrame;
 
 
public class Fenetre extends JFrame {
 
    private Panneau pan = new Panneau();
    private final KeyboardListener keyboardlistener = new KeyboardListener(pan);
    private int i = 0;
 
 
    public Fenetre(){
 
        this.setFocusable(true);
        this.setTitle("Props'Fall");
        this.setSize(1000, 1000);
        this.setResizable(true);
        this.setLocationRelativeTo(null);              
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);   
        this.setContentPane(pan);
        this.setVisible(true);
        if (i == 0){
            addKeyListener(keyboardlistener);
            i++;
        }
        //pan.Movement();?
        //pan.Gravity();?
        //Timer ici?
    }
}

Mon Panneau(dessin) :

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
117
118
119
120
121
package props.fall;
 
 
import java.awt.Graphics;
import javax.swing.JPanel;
 
public class Panneau extends JPanel { 
    private int posXPersonnage;
    private int posYPersonnage;
    private int posXCaisse;
    private int posYCaisse;
    private int height;
    private int width;
    private int i = 0, j = 0, ii = 2;
    private final Personnage pers = new Personnage();
    private final MurSol mursol = new MurSol();
    private final Fond fond = new Fond();
    private final Caisse caisse = new Caisse();
    private boolean haut = false, droit = false, gauche = false, ausol = false, saut = false;
 
    @Override
    public void paintComponent(Graphics g){ 
        if(i == 0){
            posXPersonnage = getWidth() / 2;
            posYPersonnage = getHeight() -150;
            i++;
        }
        height = this.getHeight();
        width = this.getWidth();
        posXCaisse = 200;
        posYCaisse = 200;
        fond.PaintFond(g, width, height);
        pers.PaintPersonnage(g, posXPersonnage, posYPersonnage);
        mursol.PaintMurSol(g, width, height);
        caisse.PaintCaisse(g, posXCaisse, posYCaisse);
        Movement();
        Gravity();
        repaint();
        //Timer ici?
    }
 
    public void Movement(){
        while (haut){
            while(saut){
                if(j <= 20){
                    j++;
                    posYPersonnage -= 20;
                    if(j == 20){
                        saut = false;                       
                    }
                }
                break;
            }    
            break;
        }
 
        while (droit){
            posXPersonnage += 5;
            if (posXPersonnage > this.getWidth() - 81){
                posXPersonnage = this.getWidth() - 81;
            }
            break;
        }
        while (gauche){
            posXPersonnage -= 5;
            if(posXPersonnage < 51){
                posXPersonnage = 51;
            }
            break;
        }
    }
 
    public void Gravity(){
        if (posYPersonnage < getHeight() - 85){
            ausol = true;
        }
        while(ausol){
            posYPersonnage += 10;
            break;
        }
        if (posYPersonnage >= getHeight() - 85){
            posYPersonnage = getHeight() - 85;
            ausol = false;
            saut = true;
            j = 0;
            ii = 2;
        }
    }
 
    public void StopSaut(){
        ii -= 1;
        j = 0;
        if(ii == 0){
            saut = false;
        }
    }
 
    public void DeplacementHaut1(){
        haut = true;               
    }
 
    public void DeplacementDroit1(){
        droit = true;              
    }
 
    public void DeplacementGauche1(){
        gauche = true;              
    }
 
    public void DeplacementHaut0(){
        haut = false;              
    }
 
    public void DeplacementDroit0(){
        droit = false;               
    }
 
    public void DeplacementGauche0(){
        gauche = false;                
    }
}

Mon KeyboardListener :

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
package props.fall;
 
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
 
 
public class KeyboardListener extends KeyAdapter {
        Panneau panneau; 
 
        public KeyboardListener(Panneau panneau) {
            this.panneau = panneau;
        }
 
 
        @Override
        public void keyPressed(KeyEvent event) {
 
             int keycode = event.getKeyCode();                         
             switch (keycode) {
                    case KeyEvent.VK_LEFT:
                        panneau.DeplacementGauche1();
                        break;
                    case KeyEvent.VK_RIGHT:
                        panneau.DeplacementDroit1();
                        break;
                    case KeyEvent.VK_UP:
                        panneau.DeplacementHaut1();
                        break;
                    default:                 
                        break;
             }
       }
 
        @Override
        public void keyReleased(KeyEvent event) {
 
             int keycode = event.getKeyCode();                        
             switch (keycode) {
                    case KeyEvent.VK_LEFT:
                        panneau.DeplacementGauche0();
                        break;
                    case KeyEvent.VK_RIGHT:
                        panneau.DeplacementDroit0();
                        break;
                    case KeyEvent.VK_UP:
                        panneau.DeplacementHaut0();
                        panneau.StopSaut();
                        break;
                    default:                 
                        break;
             }
       }
}

Ici mon programme fonctionne mais avec le repaint (donc n'est pas réellement utilisable).

Dans Panneau :

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
...
 
import javax.swing.Timer;
 
...
 
private final Timer timer;
 
...
 
public class Panneau ...
 
public Panneau() {
 
    ...
 
        timer = new Timer(33, new ActionListener() {
 
         public void actionPerformed(ActionEvent event) {
 
                 // on mémorise la position actuelle du personnage
                 int x = posXPersonnage;
                 int y = posYPersonnage;
 
                 // on appelle les méthodes qui modifies les coordonnées du personnage
                // bien sûr, il faut enlever les appels de ces méthodes de la méthode paint() 
                movement();
                 gravity();
 
                 // si les coordonnées du personnage ont changé redessiner (sinon c'est pas la peine)
                 if ( x!=posXPersonnage || y!=yPersonnage ) {
                     repaint();
                 }
 
 
        }
 
    });
 
 
}
 
public void startAnim() {
    timer.start();
}
 
public void stopAnim() {
    timer.stop();
}

Pour démarrer :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Fenetre ...
 
public Fenetre() {
 
...
 
this.addWindowListener(new WindowAdapter() {
    @Override
    public void windowClosed(WindowEvent e) {
         pan.stopAnim();
    }
});
 
this.setVisible(true);
pan.startAnim();

21/11/2014, 21h03
Parasoul

Je te remercie pour ton aide précieuse. Je vais continuer à travailler mon code en regardant toutes les solutions que tu m'as donné. Je met en résolu le topic.