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
|
abstract class ObjetGraphique
{
// on definit des variables qui vont nous servir pour
// tous les objets qui heriteront de cette classe
protected int x;
protected int y;
int getY(){return y;}
int getX(){return x;}
// la declaration de la methode abstraite
public abstract void dessine(Graphics g);
}
class Score extends ObjetGraphique
{
boolean vie_perdue;
public Score(int y)
{
this.y = y;
vie_perdue=false;
}
public void setvie_perdue()
{
vie_perdue=true;
}
public void dessine(Graphics g)
{
if( vie_perdue==false)
{
g.setColor(Color.YELLOW);
g.fillOval(5, y, AireDeJeu.BORDURE-10, AireDeJeu.BORDURE-10);
}
}
}
/*
** La classe brique qui herite de ObjetGraphique
*/
class Brique extends ObjetGraphique
{
boolean cassee;
public final static int brique_largeur=40;
public final static int brique_hauteur=20;
public Brique(int x, int y)
{
this.x = x;
this.y = y;
cassee=false;
}
public void setcassee()
{
cassee=true;
}
public void dessine(Graphics g)
{
if( cassee==false)
{
g.setColor(Color.YELLOW);
g.fill3DRect(x, y, brique_largeur, brique_hauteur, true);
}
}
public boolean getcassee()
{
return cassee;
}
}
/*
** La classe balle qui herite de ObjetGraphique
*/
class Balle extends ObjetGraphique implements Runnable
{
// on definit une constante qui decrit le diametre de
// notre balle
public final static int DIAMETRE_BALLE = 15;
// on definit les variables propres à notre balle
private int directionX;
private int directionY;
private Thread myThread;
/*
** le constructeur de balle
*/
public Balle()
{
x = 40;
y = 300;
directionX = AireDeJeu.VITESSE;;
directionY = -AireDeJeu.VITESSE;;
myThread = new Thread(this);
myThread.start();
}
//accesseur ne renvoie rien car on change la valeur de directionY un parametre a qui permet de chnger cette variable
void setDirectionY(int a){directionY=a;}
void setDirectionX(int a){directionX=a;}
void initBalle()
{
x=40;
y=300;
directionX=AireDeJeu.VITESSE;
directionY=-AireDeJeu.VITESSE;
}
/*
** la methode run qui provient de l'interface
** Runnable
*/
public void run()
{
while (true)
{
try
{
/*
**code qui gere les rebonds de la balle sur les limites de l'aire de jeu
*/
Thread.sleep(20);
}
catch (Exception ex) {}
}
}
public void dessine(Graphics g)
{
g.setColor(Color.RED);
g.fillOval(x, y, DIAMETRE_BALLE, DIAMETRE_BALLE);
}
}
/*
** La classe palette qui herite de ObjetGraphique
*/
class Palette extends ObjetGraphique implements MouseMotionListener
{
int Largeur=40;
int Hauteur=350;
//acceseur
int getLargeur(){return Largeur;}
int getHauteur(){return Hauteur;}
public void dessine(Graphics g)
{
g.setColor(Color.GREEN);
g.fillRoundRect(x, Hauteur, Largeur, 15, 10, 10);
}
//**Palette herite de ObjetGraphique
public void mouseMoved(MouseEvent e)
{
x = e.getX();
if(x < AireDeJeu.BORDURE)
{
x = AireDeJeu.BORDURE;
}
//**on prend 45 car linux prends une bordure de 5 pour la fenetre**/
if(x > AireDeJeu.LARGEUR_AIRE_DE_JEU-AireDeJeu.BORDURE-Largeur-5)
{
x=AireDeJeu.LARGEUR_AIRE_DE_JEU-AireDeJeu.BORDURE-Largeur-5;
}
}
public void mouseDragged(MouseEvent e)
{
// vide
}
}
/*
** La classe AireDeJeu qui herite de JPanel
** un composant de l'API Java qui va etre
** utilise pour recuperer un contexte
** graphique et donc nous permettre de
** dessiner
*/
class AireDeJeu extends JPanel implements Runnable
{
// ici on definit des constantes qui vont nous
// servir pour le reste du programme
public final static int LARGEUR_AIRE_DE_JEU = 355;
public final static int HAUTEUR_AIRE_DE_JEU = 400;
public final static int BORDURE = 20;
public final static int VITESSE = 3;
// puis on definit des variables
private Thread myThread;
private int score = 0;
private Balle maBalle;
private Palette maPalette;
private ObjetGraphique[] objets_a_Afficher;
private boolean perdu=false;
private boolean gagne=false;
private Image image_GAGNE;
private Image image_PERDUE;
private int compteur=0;
/*
** le constructeur
*/
public AireDeJeu()
{
// allocation des objets
myThread = new Thread(this);
maBalle = new Balle();
maPalette = new Palette();
objets_a_Afficher = new ObjetGraphique[29];
// on rajoute 24 briques
int h = 0;
for (int i = 0; i < 6; i++)
{
for (int j = 0; j < 4; j++)
{
objets_a_Afficher[h] = new Brique(30 + i * 50, 30 + j * 30);
h++;
}
}
for (int i = 1; i < 4; i++)
{
objets_a_Afficher[h] = new Score((HAUTEUR_AIRE_DE_JEU*4/5)-(i*20));
h++;
}
addMouseMotionListener(maPalette);
// on rajoute la balle et la palette
objets_a_Afficher[27] = maBalle;
objets_a_Afficher[28] = maPalette;
myThread.start();
image_GAGNE = getToolkit().getImage("Gagne.gif");
image_PERDUE = getToolkit().getImage("GameOver200.gif");
}
/*
** on dessine tous nos objets graphiques
*/
public void dessineAll(Graphics g)
{
for (int i = 0; i < 29; i++) {
objets_a_Afficher[i].dessine(g);
}
}
/*
** la methode run qui provient de l'interface Runnable
** et qui va permettre de redessinner notre aire de jeu
** toutes les 10ms
*/
public void run()
{
while ((gagne||perdu)==false)
{
try
{
repaint();
Thread.sleep(10);
} catch (Exception ex) { }
}
}
/*
** la methode que l'on herite de JPanel
** et qui va nous permettre de recuperer
** un contexte graphique dans lequel on
** va pouvoir dessiner
*/
public void paint(Graphics g)
{
g.setColor(Color.RED);
g.fillRect(0, 0, getWidth(), getHeight());
g.setColor(Color.BLACK);
g.fillRect(BORDURE, BORDURE, getWidth() - 2 * BORDURE, getHeight());
g.setColor(Color.WHITE);
g.setFont(new Font("Arial", Font.BOLD, 12));
g.drawString("Score : " + score, 250, 13);
if(gagne==true){g.drawImage(image_GAGNE, (LARGEUR_AIRE_DE_JEU-200)/2, (HAUTEUR_AIRE_DE_JEU-200)/2, this);};
if(perdu==true){g.drawImage(image_PERDUE, (LARGEUR_AIRE_DE_JEU-200)/2, (HAUTEUR_AIRE_DE_JEU-200)/2, this);};
if((gagne||perdu)==false){dessineAll(g);}
}
}
/*
** La classe fenetre qui contient
** une aire de jeu
*/
class Fenetre extends JFrame
{
private AireDeJeu aireDeJeu;
public Fenetre()
{
aireDeJeu = new AireDeJeu();
getContentPane().add(aireDeJeu);
setSize(AireDeJeu.LARGEUR_AIRE_DE_JEU + 5, AireDeJeu.HAUTEUR_AIRE_DE_JEU + 10);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setResizable(false);
setVisible(true);
}
/*
** le point d'entree du programme
*/
public static void main(String args[])
{
Fenetre f = new Fenetre();
}
} |
