Mettre en pause mon programme

**JarJarBinks16** · 20/04/2018, 15h05

Bonjour a tous,

Alors je suis en université, et je doit créer un casse briques je l'ai fini mais j'aimerais que lorsque l'utilisateur lance le programme j'aimerais que a tous moment s'il appuie sur une touche que j'aurais défini et le jeu se mettrais en pause pendant une durée déterminer Comment pourrait-je faire ? j'ai deja essayer le Theard.sleep mais cela ne marche pas je ne peut même pas le compiler.

Merci d'avance pour vos réponse.

**thelvin** · 20/04/2018, 15h14

Hello,

tout dépend de la bibliothèque de jeu que tu utilises.

Mais pour mettre en pause un jeu, il ne faut plus faire bouger ce qu'il y a dedans. C'est tout.
Thread.sleep() ou similaire ne font pas ce genre de choses. C'est juste ton programme qui, avant, faisait bouger les trucs qu'il y a à l'écran, et quand c'est en pause il doit cesser de le faire.

**JarJarBinks16** · 20/04/2018, 15h24

Merci, alors justement j'ai chercher mais je vois pas comment "figer" l’écran au moment précis ou l'utilisateurs appuie sur la touche.

**thelvin** · 20/04/2018, 15h39

Comme je l'ai dit, en arrêtant de dire aux trucs à l'écran de bouger, lorsque l'utilisateur appuie sur la touche.

Mais, comme je l'ai dit, ça dépend surtout de la bibliothèque de jeu que tu utilises.

**JarJarBinks16** · 20/04/2018, 15h44

Quand vous dites bibliothèque vous parlez des chose importer comme :

Code :

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

1
2
3
import java.awt.Color;
import java.util.Scanner;
import java.awt.Point;

j'utilise sa puis apres j'ai le gameGUI c'est notrre interface dans le gameGUI on as :

Code :

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

1
2
3
4
import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;
import java.awt.event.*;

voila car je ne vois pas vraiment.

**joel.drigo** · 20/04/2018, 19h45

Envoyé par JarJarBinks16

Quand vous dites bibliothèque vous parlez des chose importer comme :

Oui c'est plus ou moins ça. Tu aurais juste pu dire que tu utilisais Swing (bibliothèque graphique) sans autre bibliothèque (comme Slick2D, ou JMonkeyEngine, ou encore LWJGL...).

Alors la réponse dépend de la bibliothèque que tu utilises mais aussi de la façon que tu l'utilises, ou plutôt comment tu as programmé le jeu et en particulier la boucle de jeu.

Comme dit précédemment, il suffit d'arrêter de bouger ce qu'il y a à l'écran pour que le jeu soit en pause. Enfin, pas forcément dans certains cas, puisqu'on pourrait vouloir bouger quelque chose d'autre que ce qu'on bouge quand on joue, ou une partie (par exemple, dans un jeu de plateforme, le personnage pourrais jouer aux cartes avec les énemis pendant la pause ou des trucs comme ça, façon pause d'un tournage de film). Et on veut empêcher l'interaction utilisateur, du moins celle qui contrôle le game play (pas tout, sinon on ne pourrait pas sortir de la pause).

En gros et simplifié une boucle de jeu c'est :

Code pseudocode :

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

1
2
3
4
5
 
tant qu'on joue faire
    mettre à jour le modèle (la position de la raquette, de la balle...) en fonction des états, et traiter les interactions (collisions) entre entités du modèle (si la balle touche une brique, elle casse...)
    mettre à jour l'affichage
fin tant que

avec un système d'écouteur d’événements qui fait en gros :

Code :

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

 capter l'interaction et mettre à jour des états correspondants (si on a appuyer sur droite, la raquette doit aller vers la droite)

Le plus simple à mon avis est que cette boucle soit faite par un timer Swing (ce n'est pas le plus optimisé, mais le plus simple à programmer, parce que tout se passe dans le même thread, celui de Swing (L'Event Dispatch Thread)). Donc plutôt qu'un "faire tant que", c'est un "faire tous les x millisecondes". C'est plus simple en plus de gérer le frame rate (si le temps pris par l'ensemble des traitements est inférieur à celui-ci, puisqu'il s'agit du délai du timer) et c'est simple à suspendre et à relancer (méthode stop et start).
Le plus simple c'est de suspendre le timer et de désenregistrer les écouteurs pour entrer en pause, puis de relancer le timer et de réenregistrer les écouteurs pour sortir de la pause. Mais on peut vouloir faire quand même tourner la boucle de jeu (faire une animation pendant la pause par exemple) : dans ce cas, au lieu de stopper et relancer le timer, il suffit utiliser un état (un booléen).

Voici ci-après un exemple, ou la pause est fait par arrêt du timer et l'interaction suspendu par désenregistrement de l'écouteur. Les touches flêches permettent de donner une direction au mobile (une balle), la touche espace permet d'entrer en pause ou sortir, la touche esc permet de changer de mode (mode 1: il faut laisser la touche enfoncée pour que la balle se déplace, mode 2: pas besoin de laisser la touche), les deux modes permettant de voir les différents cas qu'on peut avoir. Si on iconifie ou désactive la fenêtre, on passe en pause également (difficile de jouer si on ne voit pas la fenêtre). J'ai simplifié la partie modèle qui se partage entre gameloop et vue (donc avec des états duppliqués), et sans introduire d'entités en particulier (ce n'est pas l'objet du code ici).

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
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
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.KeyEventDispatcher;
import java.awt.KeyboardFocusManager;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
 
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
 
public class ExemplePauseSwing1 extends JPanel {
 
	public static int RAY = 10;
	private static int DIAM = RAY*2;
 
	private static Font FONT1 = new Font("Arial", Font.BOLD, 25);
	private static Font FONT2 = new Font("Arial", Font.BOLD, 10);
 
	private int x;
	private int y;
	private boolean paused;
	private boolean mode;
 
	public ExemplePauseSwing1() {
		super(true);
		setBackground(Color.BLACK);
		x=RAY;
		y=RAY;
	} 
 
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		Graphics2D g2d = (Graphics2D)g;
		g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
		if ( paused ) {
			g.setColor(Color.LIGHT_GRAY);
		}
		else {
			g2d.setPaint(Color.WHITE);
		}
		g.fillOval(x-RAY, y-RAY, DIAM, DIAM);
 
		if ( paused ) {
			g.setColor(Color.YELLOW);
			g.setFont(FONT1);
			FontMetrics fm = g.getFontMetrics();
			g.drawString("PAUSE", (int)((getWidth()-fm.getStringBounds("PAUSE", g).getWidth())/2), (getHeight()+fm.getAscent())/2);
		}
		else {
			g.setColor(Color.BLUE);
			g2d.setXORMode(Color.WHITE);
			g.setFont(FONT2);
			FontMetrics fm = g.getFontMetrics();
			g.drawString("Mode " + (mode?2:1), 5, (getHeight()-5-fm.getAscent()+fm.getAscent()));
		}
 
	}
 
	public void setPaused(boolean paused) {
		if ( this.paused!=paused ) {
			this.paused=paused;
			repaint();
		}
	}
 
	public void setMode(boolean mode) {
		if ( this.mode!=mode ) {
			this.mode=mode;
			repaint();
		}
	} 
 
	public void moveBall(int dx, int dy) {
		if ( !paused ) {
			x+=dx;
			y+=dy;
			if ( x-RAY<0 ) {
				x=RAY;
			}
			else if ( x+RAY>=getWidth() ) {
				x=getWidth()-RAY-1;
			}
			if ( y-RAY<0 ) {
				y=RAY;
			}
			else if ( y+RAY>=getHeight() ) {
				y=getHeight()-RAY-1;
			}
			repaint();
		}
	}
 
 
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Démo");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		ExemplePauseSwing1 panel = new ExemplePauseSwing1();
 
		frame.add(panel);
 
		class GameLoop implements ActionListener {
 
			private boolean pause;
			private boolean up;
			private boolean down;
			private boolean right;
			private boolean left;
			private int dx;
			private int dy;
			private boolean mode;
 
			@Override
			public void actionPerformed(ActionEvent e) {
				panel.moveBall(dx,dy);
			}
 
			public void setPause(boolean pause) {
				this.pause=pause;
				panel.setPaused(pause);
			}
 
			public void togglePause() {
				setPause(!pause);
			}
 
			public void up(boolean b) {
				if ( mode ) {
					if ( b ) {
						this.down=false;
					}
					else {
						return;
					}
				}
				this.up=b;
				updateDy();
			}
 
			public void left(boolean b) {
				if ( mode ) {
					if ( b ) {
						this.right=false;
					}
					else {
						return;
					}
				}
				this.left=b;
				updateDx();
			}
 
			public void right(boolean b) { 
				if ( mode ) {
					if ( b ) {
						this.left=false;
					}
					else {
						return;
					}
				}
 
				this.right=b;
				updateDx();
			}
 
			public void down(boolean b) { 
				if ( mode ) {
					if ( b ) {
						this.up=false;
					}
					else {
						return;
					}
				}
 
				this.down=b;
				updateDy();
			}
 
			private void updateDy() {
				if ( this.down && this.up ) {
					dy=0;
				}
				else if ( this.down ) {
					dy=1;
				}
				else if ( this.up ) {
					dy=-1;
				}
				else {
					dy=0;
				}
			}
 
			private void updateDx() {
				if ( this.right && this.left ) {
					dx=0;
				}
				else if ( this.right ) {
					dx=1;
				}
				else if ( this.left ) {
					dx=-1;
				}
				else {
					dx=0;
				}
			}
 
			public void toggleMode() {
				mode=!mode;
				panel.setMode(mode);
				if ( !mode ) {
					up=down=right=left=false;
					updateDx();
					updateDy();
				}
			}
 
			public boolean isPause() {
				return pause;
			}
 
		}
		GameLoop gameLoop = new GameLoop();
 
		Timer timer = new Timer(33, gameLoop);
 
		KeyEventDispatcher keyEventDispatcher = new KeyEventDispatcher() {
 
			@Override
			public boolean dispatchKeyEvent(KeyEvent e) {
				boolean dispatch=true;
				switch(e.getID()) {
				case KeyEvent.KEY_RELEASED:
					switch(e.getKeyCode()) {
					case KeyEvent.VK_UP:
						gameLoop.up(false);
						dispatch=false;
						break;
					case KeyEvent.VK_DOWN:
						gameLoop.down(false);
						dispatch=false;
						break;
					case KeyEvent.VK_RIGHT:
						gameLoop.right(false);
						dispatch=false;
						break;
					case KeyEvent.VK_LEFT:
						gameLoop.left(false);
						dispatch=false;
						break;
					}
					break;
				case KeyEvent.KEY_PRESSED: 
					switch(e.getKeyCode()) {
					case KeyEvent.VK_UP:
						gameLoop.up(true);
						dispatch=false;
						break;
					case KeyEvent.VK_DOWN:
						gameLoop.down(true);
						dispatch=false;
						break;
					case KeyEvent.VK_RIGHT:
						gameLoop.right(true);
						dispatch=false;
						break;
					case KeyEvent.VK_LEFT:
						gameLoop.left(true);
						dispatch=false;
						break;
					}
					break;
				}
				return !dispatch;
			}
 
		};
		KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(new KeyEventDispatcher() {
 
			boolean pauserelease=true;
 
			@Override
			public boolean dispatchKeyEvent(KeyEvent e) {
				boolean dispatch=true;
				switch(e.getID()) { 
				case KeyEvent.KEY_RELEASED:
					switch(e.getKeyCode()) { 
					case KeyEvent.VK_SPACE:
						pauserelease=true;
						dispatch=false;
						break;
					}
					break;
				case KeyEvent.KEY_PRESSED: 
					switch(e.getKeyCode()) { 
					case KeyEvent.VK_SPACE:
						if ( pauserelease ) {
							gameLoop.togglePause();
							if ( gameLoop.isPause() ) {
								timer.stop();
								KeyboardFocusManager.getCurrentKeyboardFocusManager().removeKeyEventDispatcher(keyEventDispatcher);
							}
							else {
								timer.start();
								KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(keyEventDispatcher);
							}
							pauserelease=false;
						}
						dispatch=false;
						break;
					case KeyEvent.VK_ESCAPE:
						gameLoop.toggleMode();
						dispatch=false;
						break;
					}
					break;
				}
				return !dispatch;
			}
		});
		KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(keyEventDispatcher);
 
		frame.setSize(300,300);
		frame.setLocationRelativeTo(null);
		WindowAdapter windowAdapter = new WindowAdapter() {
			@Override
			public void windowOpened(WindowEvent e) {
				timer.start();
			}
			@Override
			public void windowDeactivated(WindowEvent e) {
				gameLoop.setPause(true);
				timer.stop();
				KeyboardFocusManager.getCurrentKeyboardFocusManager().removeKeyEventDispatcher(keyEventDispatcher);
			}
			@Override
			public void windowClosed(WindowEvent e) {
				timer.stop();
			}
			@Override
			public void windowIconified(WindowEvent e) {
				gameLoop.setPause(true);
				timer.stop();
				KeyboardFocusManager.getCurrentKeyboardFocusManager().removeKeyEventDispatcher(keyEventDispatcher);
			}
		};
		frame.addWindowListener(windowAdapter);
		frame.addWindowStateListener(windowAdapter);
		frame.setVisible(true);
 
	}
 
}

Le même, mais avec un état pour gérer la pause au lieu de suspendre le timer et ajouter/retirer les écouteurs., ce qui me permet de faire clignoter la balle pendant la pause. On pourrait se servir d'un système similaire pour sortir de la pause au bout d'un temps déterminé, ce que tu évoques.

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
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
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
 
public class ExemplePauseSwing2 extends JPanel {
 
	public static int RAY = 10;
	private static int DIAM = RAY*2;
 
	private static Font FONT1 = new Font("Arial", Font.BOLD, 25);
	private static Font FONT2 = new Font("Arial", Font.BOLD, 10);
 
	private int x;
	private int y;
	private boolean paused;
	private boolean mode;
 
	public ExemplePauseSwing2() {
		super(true);
		setBackground(Color.BLACK);
		x=RAY;
		y=RAY;
	} 
 
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		Graphics2D g2d = (Graphics2D)g;
		g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
		if ( paused ) {
			g.setColor(getBallColor());
		}
		else {
			g2d.setPaint(Color.WHITE);
		}
		g.fillOval(x-RAY, y-RAY, DIAM, DIAM);
 
		if ( paused ) {
			g.setColor(Color.YELLOW);
			g.setFont(FONT1);
			FontMetrics fm = g.getFontMetrics();
			g.drawString("PAUSE", (int)((getWidth()-fm.getStringBounds("PAUSE", g).getWidth())/2), (getHeight()+fm.getAscent())/2);
		}
		else {
			g.setColor(Color.BLUE);
			g2d.setXORMode(Color.WHITE);
			g.setFont(FONT2);
			FontMetrics fm = g.getFontMetrics();
			g.drawString("Mode " + (mode?2:1), 5, (getHeight()-5-fm.getAscent()+fm.getAscent()));
		}
 
	}
 
	private Color getBallColor() {
		long time = (System.currentTimeMillis()%1000);
		if ( time>500 ) {
			return Color.RED;
		}
		else {
			return Color.WHITE;
		}
	}
 
	public void setPaused(boolean paused) {
		if ( this.paused!=paused ) {
			this.paused=paused;
			repaint();
		}
	}
 
	public void setMode(boolean mode) {
		if ( this.mode!=mode ) {
			this.mode=mode;
			repaint();
		}
	} 
 
	public void moveBall(int dx, int dy) {
		if ( !paused ) {
			x+=dx;
			y+=dy;
			if ( x-RAY<0 ) {
				x=RAY;
			}
			else if ( x+RAY>=getWidth() ) {
				x=getWidth()-RAY-1;
			}
			if ( y-RAY<0 ) {
				y=RAY;
			}
			else if ( y+RAY>=getHeight() ) {
				y=getHeight()-RAY-1;
			}
			repaint();
		}
	}
 
 
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Démo");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		ExemplePauseSwing2 panel = new ExemplePauseSwing2();
 
		frame.add(panel);
 
		class GameLoop implements ActionListener {
 
			private boolean pause;
			private boolean up;
			private boolean down;
			private boolean right;
			private boolean left;
			private int dx;
			private int dy;
			private boolean mode;
 
			@Override
			public void actionPerformed(ActionEvent e) {
				if ( !pause ) {
					panel.moveBall(dx,dy);
				}
				else {
					panel.repaint();
				}
			}
 
			public void setPause(boolean pause) {
				this.pause=pause;
				panel.setPaused(pause);
			}
 
			public void togglePause() {
				setPause(!pause);
			}
 
			public void up(boolean b) {
				if ( pause ) return; 
				if ( mode ) {
					if ( b ) {
						this.down=false;
					}
					else {
						return;
					}
				}
				this.up=b;
				updateDy();
			}
 
			public void left(boolean b) {
				if ( pause ) return;
				if ( mode ) {
					if ( b ) {
						this.right=false;
					}
					else {
						return;
					}
				}
				this.left=b;
				updateDx();
			}
 
			public void right(boolean b) {
				if ( pause ) return; 
				if ( mode ) {
					if ( b ) {
						this.left=false;
					}
					else {
						return;
					}
				}
 
				this.right=b;
				updateDx();
			}
 
			public void down(boolean b) {
				if ( pause ) return; 
				if ( mode ) {
					if ( b ) {
						this.up=false;
					}
					else {
						return;
					}
				}
 
				this.down=b;
				updateDy();
			}
 
			private void updateDy() {
				if ( this.down && this.up ) {
					dy=0;
				}
				else if ( this.down ) {
					dy=1;
				}
				else if ( this.up ) {
					dy=-1;
				}
				else {
					dy=0;
				}
			}
 
			private void updateDx() {
				if ( this.right && this.left ) {
					dx=0;
				}
				else if ( this.right ) {
					dx=1;
				}
				else if ( this.left ) {
					dx=-1;
				}
				else {
					dx=0;
				}
			}
 
			public void toggleMode() {
				mode=!mode;
				panel.setMode(mode);
				if ( !mode ) {
					up=down=right=left=false;
					updateDx();
					updateDy();
				}
			}
 
			public boolean isPause() {
				return pause;
			}
 
		}
		GameLoop gameLoop = new GameLoop();
 
		Timer timer = new Timer(33, gameLoop);
 
		KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(new KeyEventDispatcher() {
 
			private boolean pauserelease=true;
 
			@Override
			public boolean dispatchKeyEvent(KeyEvent e) {
				boolean dispatch=true;
				switch(e.getID()) {
				case KeyEvent.KEY_RELEASED:
					switch(e.getKeyCode()) {
					case KeyEvent.VK_UP:
						gameLoop.up(false);
						dispatch=false;
						break;
					case KeyEvent.VK_DOWN:
						gameLoop.down(false);
						dispatch=false;
						break;
					case KeyEvent.VK_RIGHT:
						gameLoop.right(false);
						dispatch=false;
						break;
					case KeyEvent.VK_LEFT:
						gameLoop.left(false);
						dispatch=false;
						break;
					case KeyEvent.VK_SPACE:
						pauserelease=true;
						dispatch=false;
						break;					
					}
					break;
				case KeyEvent.KEY_PRESSED: 
					switch(e.getKeyCode()) {
					case KeyEvent.VK_UP:
						gameLoop.up(true);
						dispatch=false;
						break;
					case KeyEvent.VK_DOWN:
						gameLoop.down(true);
						dispatch=false;
						break;
					case KeyEvent.VK_RIGHT:
						gameLoop.right(true);
						dispatch=false;
						break;
					case KeyEvent.VK_LEFT:
						gameLoop.left(true);
						dispatch=false;
						break;
					case KeyEvent.VK_SPACE:
						if ( pauserelease ) {
							gameLoop.togglePause();
							pauserelease=false;
						}
						dispatch=false;
						break;
					case KeyEvent.VK_ESCAPE:
						gameLoop.toggleMode();
						dispatch=false;
						break;
					}
					break;
				}
				return !dispatch;
			}
 
		});
 
		frame.setSize(300,300);
		frame.setLocationRelativeTo(null);
		WindowAdapter windowAdapter = new WindowAdapter() {
			@Override
			public void windowOpened(WindowEvent e) {
				timer.start();
			}
			@Override
			public void windowDeactivated(WindowEvent e) {
				gameLoop.setPause(true);
			}
			@Override
			public void windowClosed(WindowEvent e) {
				timer.stop();
			}
			@Override
			public void windowIconified(WindowEvent e) {
				gameLoop.setPause(true);
			}
		};
		frame.addWindowListener(windowAdapter);
		frame.addWindowStateListener(windowAdapter);
		frame.setVisible(true);
 
	}
 
}

On est pas obligé de gérer l'affichage du mode pause dans le composant d'affichage du jeu lui-même. On pourrait utiliser un JLayer (qui a ses avantages, comme par exemple permettre de faire des effets plus évolués pour marquer la pause, comme du blur par exemple, ou simplement afficher une autre animation).

**JarJarBinks16** · 20/04/2018, 22h05

Merci énormément, en faite je suis en première année et l'interface graphique avec le swing c'est le prof qui nous la donner sinon merci vous m'avez aidez.

**joel.drigo** · 21/04/2018, 11h57

Peu importe, ce que tu te donnes le prof, c'est comme si c'était une bibliothèque. Le principe reste le même : ne pas appeler les méthodes qui retranscrivent les mouvements dans cette interface Swing et ne pas tenir compte des interactions utilisateurs.

Sans ton code, il est difficile de te guider plus.

**JarJarBinks16** · 21/04/2018, 13h21

D'accord, j'ai reussi merci beaucoup

Mettre en pause mon programme

Java

Discussions similaires

Partager

Partager