Un problème avec un jeu de tennis

**Electroniktor** · 03/07/2007, 15h21

Je me demandais justement si on pouvait simplifier (factoriser) une telle expression ! J'ai ma réponse ...

Mais cela ne résoud pas le problème du compteur fou ! J'ai beau cherché une solution, je n'en trouve pas !

**Emmanuel Delahaye** · 03/07/2007, 15h35

Envoyé par Electroniktor

Voilà mon code.

Code :

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

1
2
3
4
5
6
7
8
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio2.h>
#include <windows.h>
 
#include "affichage.h"
<...>

Ton code est toujours aussi incomplet...

L'évaluation de la vitesse doit être faite après chaque mouvement de balle et non dans la boucle à 1 ms...

J'ai déplacé les horribles et inutiles globales.

Ceci marchouille... Pose des questions si tu ne comprends pas...

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
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio2.h>
#include <windows.h>
 
#include "affichage.h"
 
#define MS(ms) (CLOCKS_PER_SEC / (1000.0 / (ms)))
 
enum dir
{ NW, NE, SE, SW };
 
struct ball
{
   int x;
   int y;
   enum dir dir;
};
 
struct plot
{
   int x;
   int y1;
   int y2;
   int y3;
};
 
static void vitesse (struct ball *this, struct plot *p_plot, long *compteur,
                     long *DELAY)
{
   if (this->x == p_plot->x + 1
       && (this->y == p_plot->y1
           || this->y == p_plot->y2 || this->y == p_plot->y3))
   {
      (*compteur)++;
      gotoxy (1, 1);
      printf ("%ld", *compteur);
   }
}
 
static int move_ball (struct ball *this, struct plot *p_plot,
                      struct field *p_field)
{
   int end = 0;
   /* Si il n'y a pas collision avec la raquette */
   if (!(this->x == p_plot->x
         && (this->y == p_plot->y1
             || this->y == p_plot->y2 || this->y == p_plot->y3)))
   {
      if (this->x == p_field->x_mid)
      {
         gotoxy (this->x, this->y), putch ('|');
      }
      else if (this->x == p_field->x_min + 1)
      {
         gotoxy (this->x, this->y), putch ('o');
      }
      else
      {
         gotoxy (this->x, this->y), putch (' ');
      }
   }
 
   switch (this->dir)
   {
   case NW:
      this->x--;
      this->y--;
 
      /* Si il y a collision avec la partie haute de la raquette */
      if (this->x == p_plot->x && this->y == p_plot->y1)
      {
         /* rebond a 90 degre */
         this->dir = NE;
         this->x++;
      }
      /* Si il y a collision avec la partie centrale de la raquette */
      else if (this->x == p_plot->x && this->y == p_plot->y2)
      {
         this->dir = SE;
         this->x++;
         this->y++;
      }
      /* Si il y a collision avec la partie basse de la raquette */
      else if (this->x == p_plot->x && this->y == p_plot->y3)
      {
         this->dir = SE;
         this->x++;
         this->y++;
      }
      /* si touche le cote */
      else if (this->y == p_field->y_min)
      {
         /* rebond a 90 degre */
         this->dir = SW;
         this->y++;
      }
      /* si touche le fond ouest : perdu */
      else if (this->x == p_field->x_min)
      {
         end = 1;
      }
      break;
 
   case NE:
      this->x++;
      this->y--;
 
      if (this->x == p_field->x_max && this->y == p_field->y_min)
      {
         this->dir = SW;
         this->x--;
         this->y++;
      }
      else if (this->x == p_field->x_max)
      {
         this->dir = NW;
         this->x--;
      }
      else if (this->y == p_field->y_min)
      {
         this->dir = SE;
         this->y++;
      }
      break;
 
   case SE:
      this->x++;
      this->y++;
 
      if (this->x == p_field->x_max && this->y == p_field->y_max)
      {
         this->dir = NW;
         this->x--;
         this->y--;
      }
      else if (this->x == p_field->x_max)
      {
         this->dir = SW;
         this->x--;
      }
      else if (this->y == p_field->y_max)
      {
         this->dir = NE;
         this->y--;
      }
      break;
 
   case SW:
      this->x--;
      this->y++;
 
      /* Si il y a collision avec la partie haute de la raquette */
      if (this->x == p_plot->x && this->y == p_plot->y1)
      {
         this->dir = NE;
         this->x++;
         this->y--;
      }
      /* Si il y a collision avec la partie centrale de la raquette */
      else if (this->x == p_plot->x && this->y == p_plot->y2)
      {
         this->dir = NE;
         this->x++;
         this->y--;
      }
      /* Si il y a collision avec la partie basse de la raquette */
      else if (this->x == p_plot->x && this->y == p_plot->y3)
      {
         this->dir = SE;
         this->x++;
      }
 
      /* si touche le cote */
      else if (this->y == p_field->y_max)
      {
         /* rebond a 90 degre */
         this->dir = NW;
         this->y--;
      }
      /* si touche le fond ouest : perdu */
      else if (this->x == p_field->x_min)
      {
         end = 1;
      }
 
      break;
   }
   gotoxy (this->x, this->y), putch ('o');
 
   return end;
}
 
static void move_plot (struct plot *this, struct field *p_field, int c)
{
   switch (c)
   {
   case '2':
      if (this->y3 < p_field->y_max - 1)
      {
         this->y1++;
         gotoxy (this->x, this->y1), putch ('|');
         this->y2++;
         gotoxy (this->x, this->y2), putch ('|');
         this->y3++;
         gotoxy (this->x, this->y3), putch ('|');
 
         gotoxy (this->x, this->y1 - 1), putch (' ');
      }
      break;
 
   case '8':
      if (this->y1 > p_field->y_min + 1)
      {
         this->y1--;
         gotoxy (this->x, this->y1), putch ('|');
         this->y2--;
         gotoxy (this->x, this->y2), putch ('|');
         this->y3--;
         gotoxy (this->x, this->y3), putch ('|');
 
         gotoxy (this->x, this->y3 + 1), putch (' ');
      }
      break;
   }
}
 
int main (void)
{
   int end = 0;
   long compteur = 0;
   long DELAY = 250;
 
   struct field field = { 11, 6, 71, 22, 0 };
   struct ball ball = { 40, 15, NW };
   struct plot plot = { 13, 14, 15, 16 };
   clock_t echeance = clock () + MS (DELAY);
 
   titre ();
   terrain (&field);
 
   /* positions initiales */
   gotoxy (ball.x, ball.y), putch ('o');
   gotoxy (plot.x, plot.y1), putch ('|');
   gotoxy (plot.x, plot.y2), putch ('|');
   gotoxy (plot.x, plot.y3), putch ('|');
 
   /* mouvement */
   do
   {
      if (clock () > echeance)
      {
         end = move_ball (&ball, &plot, &field);
         echeance = clock () + MS (DELAY);
         vitesse (&ball, &plot, &compteur, &DELAY);
      }
 
      if (kbhit ())
      {
         int c = getch ();
         switch (c)
         {
         case '2':
         case '8':
            move_plot (&plot, &field, c);
            break;
         case 27:
            end = 1;
         }
      }
      Sleep (1);
   }
   while (!end);
 
   return 0;
 
}

avec

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
 
#ifndef H_AFFICHAGE
#define H_AFFICHAGE
 
/* affichage.h */
 
struct field
{
   int x_min;
   int y_min;
   int x_max;
   int y_max;
 
   /* calcule */
   int x_mid;
};
 
void titre (void);
void terrain (struct field *p);
 
#endif /* guard */

et

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
 
#include "affichage.h"
#include <conio2.h>
 
   void titre (void)
   {
   }
 
   void terrain (struct field *this)
   {
      int i;
 
      for (i = this->x_min + 1 ; i < this->x_max; i++)
      {
         gotoxy (i, this->y_min), putch('-');
      }
 
      this->x_mid = this->x_min + ((this->x_max-this->x_min)/2);
 
      for (i = this->y_min + 1 ; i < this->y_max; i++)
      {
 
         gotoxy (this->x_min, i), putch('|');
         gotoxy (this->x_mid, i), putch('|');
         gotoxy (this->x_max, i), putch('|');
      }
 
      for (i = this->x_min + 1 ; i < this->x_max; i++)
      {
         gotoxy (i, this->y_max), putch('-');
      }
   }

**Electroniktor** · 03/07/2007, 23h30

Ceci marchouille

Il serait mieux d'avoir quelque chose qui marche ! lol

Il y a toujours un problème avec le compteur ! Tout d'abord il va généralement de deux en deux

et parfois il n'augmente que de un (lorsque l'on touche la balle avec l'extrémité de la raquette et qu'on enlève la raquette tout de suite après) !

J'ai essayé de bidouiller un peu ... sans succès.

J'ai essayé avec des manières plus convenables ... sans succès.

Et j'ai beau chercher de nouvelles solutions, je ne trouve pas !

J'espère que la nuit me portera conseils ...

**Electroniktor** · 04/07/2007, 00h18

Bon ben voilà finalement j'ai pas eu besoin de la nuit !

On avait oublié deux conditions

!!!
Voilà ma fonction :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
static void vitesse (struct ball *this, struct plot *p_plot, long *compteur, 
                     long *DELAY)
{   
   if (this->x == p_plot->x + 1 && (this->y == p_plot->y1
                                 || this->y == p_plot->y2 
                                 || this->y == p_plot->y3
                                 || this->y == p_plot->y1 - 1
                                 || this->y == p_plot->y3 + 1))
   {
      (*compteur)++;
      gotoxy (1, 1);
      printf ("%ld", *compteur / 2);
   }
}

**souviron34** · 04/07/2007, 15h19

D'abord bravo à Emmanuel pour ce cours "main dans la main"

Ensuite juste une remarque en passant :

Comme l'a dit Emmanuel, les parenthèses, c'est bien ET pour la précédence des opérateurs ET pour la lecture.

En conséquence, je transformerais :

Code :

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

1
2
3
4
5
6
 
   if (this->x == p_plot->x + 1 && (this->y == p_plot->y1
                                 || this->y == p_plot->y2 
                                 || this->y == p_plot->y3
                                 || this->y == p_plot->y1 - 1
                                 || this->y == p_plot->y3 + 1))

en

Code :

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

1
2
3
4
5
6
7
 
   if ( (this->x == (p_plot->x + 1))   && 
        ((this->y == p_plot->y1)     ||
         (this->y == p_plot->y2)     || 
         (this->y == p_plot->y3)     ||
         (this->y == (p_plot->y1-1)) ||
         (this->y == (p_plot->y3+1)))    )

**DaZumba** · 04/07/2007, 16h15

Envoyé par souviron34

Comme l'a dit Emmanuel, les parenthèses, c'est bien ET pour la précédence des opérateurs ET pour la lecture.

Mettre des parentheses partout, c'est tout de meme exagere. Dans ce cas, il est evident que les || ont precedence: on ne va pas se mettre a evaluer le OU avant que les deux operandes ne soient connus! (le standard garanti en plus une evaluation de gauche a droite, et qu'il y a un point de sequence apres l'evaluation du premier operande, 6.5.14). Par contre, les parentheses entourant le deuxieme operande du && sont necessaires, puisqu'on veut tester tous les || ensemble.

**Electroniktor** · 04/07/2007, 16h32

Bon ben voilà ce mini jeu est terminé !

Je tenais à remercier BS C3 pour l'idée qu'il a apporté au problème principal, Emmanuel Delahaye pour l'aide qu'il m'a fournit pour écrire ce code, Souviron34 pour les informations et précisions supplémentaires et tous tous les autres qui ont participés à cette discussion !

Petite précision : ce code est en fait le mode entraînement d'un jeu de tennis plus complet qui contiendra aussi un mode multi-joueurs et un mode solo contre l'ordinateurs que je ne vais pas tarder à coder. D'autres choses arriveront aussi comme la possibilité d'enregistrer son meilleur score, un calcul des scores qui se rapproche du veritable tennis (3 manches de 6 jeux), la possibilité de choisir la couleur de sa raquette ... et pleins d'autres choses !

Encore merci et à bientôt !

affichage.c :

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
#include <conio2.h>
#include <stdio.h>
#include <stdlib.h>
 
#include "affichage.h"
 
void titre()
 
{
     printf("\t\t\t\t+----------------+\n");
     printf("\t\t\t\t|  OPEN CONSOLE  |\n");
     printf("\t\t\t\t+----------------+");
}
 
void terrain(struct field *this)
 
{ 
     printf("\n\n\n");
 
      int i;
 
      for (i = this->x_min + 1 ; i < this->x_max; i++)
      {
         gotoxy (i, this->y_min), putch('-');
      }
 
      this->x_mid = this->x_min + ((this->x_max-this->x_min)/2);
 
      for (i = this->y_min + 1 ; i < this->y_max; i++)
      {
 
         gotoxy (this->x_min, i), putch('|');
         gotoxy (this->x_mid, i), putch('|');
         gotoxy (this->x_max, i), putch('|');
      }
 
      for (i = this->x_min + 1 ; i < this->x_max; i++)
      {
         gotoxy (i, this->y_max), putch('-');
      }
 
      gotoxy( this->x_min, this->y_min), putch('+');
      gotoxy( this->x_max, this->y_min), putch('+');
      gotoxy( this->x_min, this->y_max), putch('+');
      gotoxy( this->x_max, this->y_max), putch('+');
      gotoxy( this->x_mid, this->y_min), putch('+');
      gotoxy( this->x_mid, this->y_max), putch('+');
}

affichage.h :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
void titre();
void terrain();
struct field
{
   int x_min;
   int y_min;
   int x_max;
   int y_max;
 
   /* calcule */
   int x_mid;
};

main.c :

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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio2.h>
#include <windows.h>
 
#include "affichage.h"
 
#define MS(ms) (CLOCKS_PER_SEC / (1000.0 / (ms)))
 
enum dir
{ NW, NE, SE, SW };
 
struct ball
{
   int x;
   int y;
   enum dir dir;
};
 
struct plot
{
   int x;
   int y1;
   int y2;
   int y3;
};
 
static void vitesse (struct ball *this, struct plot *p_plot, long *compteur, long *DELAY)
{   
   if ( (this->x == (p_plot->x + 1))   && 
        ((this->y == p_plot->y1)     ||
         (this->y == p_plot->y2)     || 
         (this->y == p_plot->y3)     ||
         (this->y == (p_plot->y1-1)) ||
         (this->y == (p_plot->y3+1)))    )
   {
      (*compteur)++;
      gotoxy (1, 1);
      printf ("Score : %ld", *compteur / 2);
   }
 
   switch (*compteur)
   {
      case 0:
           *DELAY = 100;
           break;
      case 10:
           *DELAY = 90;
           break;
      case 20:
           *DELAY = 80;
           break;
      case 30:
           *DELAY = 75;
           break;
      case 40:
           *DELAY = 70;
           break;
      case 50:
           *DELAY = 65;
           break;
      case 60:
           *DELAY = 60;
           break;
      case 70:
           *DELAY = 55;
           break;
      case 80:
           *DELAY = 50;
           break;
      case 90:
           *DELAY = 45;
           break;
      case 100:
           *DELAY = 40;
           break;
      case 110:
           *DELAY = 35;
           break;
      case 120:
           *DELAY = 30;
           break;
      default:
           break;
    }
}
 
static int move_ball (struct ball *this, struct plot *p_plot,
                      struct field *p_field)
{
   int end = 0;
   /* Si il n'y a pas collision avec la raquette */
   if (!(this->x == p_plot->x
         && (this->y == p_plot->y1
             || this->y == p_plot->y2 || this->y == p_plot->y3)))
   {
      if (this->x == p_field->x_mid)
      {
         gotoxy (this->x, this->y), putch ('|');
      }
      else if (this->x == p_field->x_min + 1)
      {
         gotoxy (this->x, this->y), putch ('o');
      }
      else
      {
         gotoxy (this->x, this->y), putch (' ');
      }
   }
 
   switch (this->dir)
   {
   case NW:
      this->x--;
      this->y--;
 
      /* Si il y a collision avec la partie haute de la raquette */
      if (this->x == p_plot->x && this->y == p_plot->y1)
      {
         /* rebond a 90 degre */
         this->dir = NE;
         this->x++;
      }
      /* Si il y a collision avec la partie centrale de la raquette */
      else if (this->x == p_plot->x && this->y == p_plot->y2)
      {
         this->dir = SE;
         this->x++;
         this->y++;
      }
      /* Si il y a collision avec la partie basse de la raquette */
      else if (this->x == p_plot->x && this->y == p_plot->y3)
      {
         this->dir = SE;
         this->x++;
         this->y++;
      }
 
      else if (this->x == p_plot->x 
               && this->y == p_plot->y1 - 1 
               && p_plot->y1 == p_field->y_min + 1)
      {
         this->dir = SE;
         this->x++;
         this->y++; 
      }
      /* si touche le cote */
      else if (this->y == p_field->y_min)
      {
         /* rebond a 90 degre */
         this->dir = SW;
         this->y++;
      }
      /* si touche le fond ouest : perdu */
      else if (this->x == p_field->x_min)
      {
         end = 1;
      }
      break;
 
   case NE:
      this->x++;
      this->y--;
 
      if (this->x == p_field->x_max && this->y == p_field->y_min)
      {
         this->dir = SW;
         this->x--;
         this->y++;
      }
      else if (this->x == p_field->x_max)
      {
         this->dir = NW;
         this->x--;
      }
      else if (this->y == p_field->y_min)
      {
         this->dir = SE;
         this->y++;
      }
      break;
 
   case SE:
      this->x++;
      this->y++;
 
      if (this->x == p_field->x_max && this->y == p_field->y_max)
      {
         this->dir = NW;
         this->x--;
         this->y--;
      }
      else if (this->x == p_field->x_max)
      {
         this->dir = SW;
         this->x--;
      }
      else if (this->y == p_field->y_max)
      {
         this->dir = NE;
         this->y--;
      }
      break;
 
   case SW:
      this->x--;
      this->y++;
 
      /* Si il y a collision avec la partie haute de la raquette */
      if (this->x == p_plot->x && this->y == p_plot->y1)
      {
         this->dir = NE;
         this->x++;
         this->y--;
      }
      /* Si il y a collision avec la partie centrale de la raquette */
      else if (this->x == p_plot->x && this->y == p_plot->y2)
      {
         this->dir = NE;
         this->x++;
         this->y--;
      }
      /* Si il y a collision avec la partie basse de la raquette */
      else if (this->x == p_plot->x && this->y == p_plot->y3)
      {
         this->dir = SE;
         this->x++;
      }
 
      else if (this->x == p_plot->x 
               && this->y == p_plot->y3 + 1 
               && p_plot->y3 == p_field->y_max - 1)
      {
         this->dir = SE;
         this->x++;
         this->y++; 
      }
 
      /* si touche le cote */
      else if (this->y == p_field->y_max)
      {
         /* rebond a 90 degre */
         this->dir = NW;
         this->y--;
      }
      /* si touche le fond ouest : perdu */
      else if (this->x == p_field->x_min)
      {
         end = 1;
      }
 
      break;
   }
   gotoxy (this->x, this->y), putch ('o');
 
   return end;
}
 
static void move_plot (struct plot *this, struct field *p_field, int c)
{
   switch (c)
   {
   case '2':
      if (this->y3 < p_field->y_max - 1)
      {
         this->y1++;
         gotoxy (this->x, this->y1), putch ('|');
         this->y2++;
         gotoxy (this->x, this->y2), putch ('|');
         this->y3++;
         gotoxy (this->x, this->y3), putch ('|');
 
         gotoxy (this->x, this->y1 - 1), putch (' ');
      }
      break;
 
   case '8':
      if (this->y1 > p_field->y_min + 1)
      {
         this->y1--;
         gotoxy (this->x, this->y1), putch ('|');
         this->y2--;
         gotoxy (this->x, this->y2), putch ('|');
         this->y3--;
         gotoxy (this->x, this->y3), putch ('|');
 
         gotoxy (this->x, this->y3 + 1), putch (' ');
      }
      break;
   }
}
 
int main (void)
{
   int end = 0;
   long compteur = 0;
   long DELAY = 100;
 
   struct field field = { 12, 6, 70, 22, 0 };
   struct ball ball = { 40, 15, NW };
   struct plot plot = { 14, 14, 15, 16 };
   clock_t echeance = clock () + MS (DELAY);
 
   titre ();
   terrain (&field);
 
   /* positions initiales */
   gotoxy (ball.x, ball.y), putch ('o');
   gotoxy (plot.x, plot.y1), putch ('|');
   gotoxy (plot.x, plot.y2), putch ('|');
   gotoxy (plot.x, plot.y3), putch ('|');
 
   /* mouvement */
   do
   {
      if (clock () > echeance)
      {
         end = move_ball (&ball, &plot, &field);
         echeance = clock () + MS (DELAY);
         vitesse (&ball, &plot, &compteur, &DELAY);
      }
 
      if (kbhit ())
      {
         int c = getch ();
         switch (c)
         {
         case '2':
         case '8':
            move_plot (&plot, &field, c);
            break;
         case 27:
            end = 1;
         }
      }
      Sleep (1);
   }
   while (!end);
 
   return 0;
 
}

**Emmanuel Delahaye** · 04/07/2007, 17h21

Envoyé par Electroniktor

Bon ben voilà ce mini jeu est terminé !

Tu devrais mieux regler ton compilateur :

http://emmanuel-delahaye.developpez....tm#cfg_compilo

car il reste pas mal de bugs qui n'existaient pas dans le code que j'ai publié :

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
 
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : C:\dev\forums\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
In file included from main.c:7:
affichage.h:1: warning: function declaration isn't a prototype
affichage.h:2: warning: function declaration isn't a prototype
Compiling: affichage.c
In file included from affichage.c:1:
affichage.h:1: warning: function declaration isn't a prototype
affichage.h:2: warning: function declaration isn't a prototype
affichage.c:3: warning: function declaration isn't a prototype
affichage.c: In function `titre':
affichage.c:4: warning: implicit declaration of function `printf'
affichage.c: In function `terrain':
affichage.c:14: warning: implicit declaration of function `gotoxy'
affichage.c:14: warning: implicit declaration of function `putch'
Linking console executable: console.exe
Process terminated with status 0 (0 minutes, 3 seconds)
0 errors, 8 warnings

Si tu ne comprends pas mon code, pose des questions, mais ne le modifie pas sans raisons.

Le choix de conio pour l'affichage est exclusif. Il n'est plus question d'utiliser les fonctions standard d'E/S. Je ne veux plus voir de printf(), '\n' et autre '\t'. Tout est maintenant calculé en x,y.

Et puis je ne veux plus voir ce '41'. Il s'appelle maintenant field.x_mid...

Par exemple :

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
 
#include "affichage.h"
 
#include <conio2.h>
#include <string.h>
 
void titre (void)
{
   char const s[] = "OPEN CONSOLE";
   /* centrage */
   int x = (80 - (strlen (s) + strlen ("|  |"))) / 2;
   int y = 1;
 
   gotoxy (x, y + 0), cputs ("+--------------+");
   gotoxy (x, y + 1), cprintf ("| %s |", s);
   gotoxy (x, y + 2), cputs ("+--------------+");
}
 
void terrain (struct field *this)
{
   int i;
   /* calul de la position mediane */
   this->x_mid = this->x_min + ((this->x_max - this->x_min) / 2);
 
   for (i = this->x_min; i <= this->x_max; i++)
   {
      gotoxy (i, this->y_min);
      if (i == this->x_min || i == this->x_mid || i == this->x_max)
      {
         putch ('+');
      }
      else
      {
         putch ('-');
      }
   }
 
   for (i = this->y_min + 1; i < this->y_max; i++)
   {
      gotoxy (this->x_min, i), putch ('|');
      gotoxy (this->x_mid, i), putch ('|');
      gotoxy (this->x_max, i), putch ('|');
   }
 
   for (i = this->x_min; i <= this->x_max; i++)
   {
      gotoxy (i, this->y_max);
      if (i == this->x_min || i == this->x_mid || i == this->x_max)
      {
         putch ('+');
      }
      else
      {
         putch ('-');
      }
   }
}

Mais on devrait rendre le code plus 'automatique. Il suffit en principe de définir la taille du jeu et sa position (field) pour qu'il calcule la position de la raquette. Quand à la position et à la direction initiale de la balle, elles devrait être imprévisibles, ce serait plus drôle...

**Electroniktor** · 04/07/2007, 17h56

Je n'ai pas réussi à règler mon compilo comme il le fallait je n'ai donc pas pu tester mes modifications !

J'ai quant même édité mon message en faisant quelques changements et je pense avoir résolu 3 ou 4 warnings.

Seulement, en se qui concerne les ...

Code :

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

warning: function declaration isn't a prototype

... je ne vois pas ce qu'il veut dire car je n'ai pas modifié la déclaration des fonctions et encore moins affichage.h ! Je ne vois donc pas pourquoi il y a ces messages puisque c'est le même code que celui que tu as posté !

**Emmanuel Delahaye** · 04/07/2007, 18h02

Envoyé par Electroniktor

Je n'ai pas réussi à règler mon compilo comme il le fallait

Hein ? Tu as quoi comme IDE ?

Seulement, en se qui concerne les ...

Code :

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

warning: function declaration isn't a prototype

... je ne vois pas ce qu'il veut dire car je n'ai pas modifié la déclaration des fonctions et encore moins affichage.h ! Je ne vois donc pas pourquoi il y a ces messages puisque c'est le même code que celui que tu as posté !

C'est un plaisanterie ?

Voilà ce que j'avais posté :

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
 
 
#ifndef H_AFFICHAGE
#define H_AFFICHAGE
 
/* affichage.h */
 
struct field
{
   int x_min;
   int y_min;
   int x_max;
   int y_max;
 
   /* calcule */
   int x_mid;
};
 
void titre (void);
void terrain (struct field *p);
 
#endif /* guard */

**Electroniktor** · 04/07/2007, 19h00

Désolé j'ai surement dû copier le code avant que tu ne modifies ton message car je n'ai pas le souvenir d'avoir supprimé ces choses là ! Et je suis sous Dev-C++ 4.9.9.2 [je n'aime pas trop l'univers de CodeBlocks (taille du texte, coloration ... )] !!

Bref. Je suis d'accord pour rendre aléatoire la position de la raquette et la direction de la balle

mais qu'entends-tu par :

Mais on devrait rendre le code plus 'automatique. Il suffit en principe de définir la taille du jeu et sa position (field) pour qu'il calcule la position de la raquette.

Si le code sera plus compliqué, je trouve qu'il l'est déjà pas mal pour un débutant comme moi (enfin je ne suis peut-être plus débutant depuis le temps !

). Enfin je ne sais pas vu que je n'ai pas tout compris ce que tu voulais dire !

**Emmanuel Delahaye** · 04/07/2007, 19h20

Envoyé par Electroniktor

Désolé j'ai surement dû copier le code avant que tu ne modifies ton message car je n'ai pas le souvenir d'avoir supprimé ces choses là ! Et je suis sous Dev-C++ 4.9.9.2 [je n'aime pas trop l'univers de CodeBlocks (taille du texte, coloration ... )] !!

Bref. Je suis d'accord pour rendre aléatoire la position de la raquette et la direction de la balle

mais qu'entends-tu par :
Si le code sera plus compliqué, je trouve qu'il l'est déjà pas mal pour un débutant comme moi (enfin je ne suis peut-être plus débutant depuis le temps !

). Enfin je ne sais pas vu que je n'ai pas tout compris ce que tu voulais dire !

En fait, la complexité est 'déplacée'.

On sépare le code en une partie 'applicative' qui est de haut niveau et une partie 'services' qui fait le sale boulot, comme calculer la position initiale de la raquette à partir de la définition du jeu (field).

Code :

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

1
2
3
4
5
6
 
   /* 60 et 40 sont la largeur et la hauteur */
   struct field *p_field = field_create (60, 40, FIELD_CENTERED, FIELD_CENTERED);
 
   struct plot *p_plot_g = plot_create (p_field, PLOT_LEFT);
   struct plot *p_plot_d = plot_create (p_field, PLOT_RIGHT);

En effet, il est extrêmement fastidieux de calculer les coordonnées à la main. Tout peut être automatisé. D'ailleurs, les coordonnées de la fenêtre (tailles) peuvent être lues avec struct text_info et gettextinfo() :

Code :

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

1
2
3
 
   struct text_info ti; 
   gettextinfo(&ti);

on a ensuite les informations dans les champs de ti... Voir la doc de conio.

**Silverstone** · 04/07/2007, 22h54

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
      /* Si il y a collision avec la partie haute de la raquette */
      if (this->x == p_plot->x && this->y == p_plot->y1)
      {
         this->dir = NE;
         this->x++;
         this->y--;
      }
      /* Si il y a collision avec la partie centrale de la raquette */
      else if (this->x == p_plot->x && this->y == p_plot->y2)
      {
         this->dir = NE;
         this->x++;
         this->y--;
      }

Tu devrais mettre à la place

Code :

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

1
2
3
4
5
6
      if (this->x == p_plot->x && (this->y == p_plot->y1 || this->y == p_plot->y2))
      {
         this->dir = NE;
         this->x++;
         this->y--;
      }

Comme ça tu répète pas 2 fois la même chose

**Electroniktor** · 04/07/2007, 23h13

Silverstone : merci d'avoir vu cela, il y aussi d'autres endroits comme ceci où je pourrai simplifier le code !

Emmanuel : en fait, je pense avoir compris le truc mais je n'en suis pas sur !

Alors concrètement, qu'aurons nous à la place de ceci :

Code :

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

1
2
3
4
5
6
7
8
fonction vitesse()
     qui gère la vitesse de la balle en fonction du nombre de coups
fonction move_ball()
     qui gère le déplacement de la balle
fonction move_plot()
     qui gère le déplacement de la raquette
fonction main()
     qui coordonne le tout

Et j'ai l'impression qu'avec ta technique, on pourra gérer beaucoup plus facilement le fait qu'il y aura deux raquettes !!!???

PS : J'oubliais ! Est-t-il possible d'utiliser les flèches directionnelles haute et basse ?

**Emmanuel Delahaye** · 05/07/2007, 02h51

Envoyé par Electroniktor

Silverstone : merci d'avoir vu cela, il y aussi d'autres endroits comme ceci où je pourrai simplifier le code !

Emmanuel : en fait, je pense avoir compris le truc mais je n'en suis pas sur !

Alors concrètement, qu'aurons nous à la place de ceci :

Code :

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

1
2
3
4
5
6
7
8
fonction vitesse()
     qui gère la vitesse de la balle en fonction du nombre de coups
fonction move_ball()
     qui gère le déplacement de la balle
fonction move_plot()
     qui gère le déplacement de la raquette
fonction main()
     qui coordonne le tout

Et j'ai l'impression qu'avec ta technique, on pourra gérer beaucoup plus facilement le fait qu'il y aura deux raquettes !!!???

Voilà. Petit à petit, je t'emmène sur le terrain de la POO... Il faut penser l'organisation du code en terme d'objets et non en termes de fonctions.

- le terrain
- les raquettes
- la balle

définir les propriétés des objets, les méthodes pour agir dessus etc.

Evidemment, le C n'étant pas OO, on aura du mal a utiliser toutes les subtilités de la POO, mais les bases (classes, par exemple ADT en C) suffisent pour travailler proprement et efficacement.

http://emmanuel-delahaye.developpez.com/tad.htm

PS : J'oubliais ! Est-t-il possible d'utiliser les flèches directionnelles haute et basse ?

Oui, bien sûr...

http://www.developpez.net/forums/sho...70&postcount=4
http://www.developpez.net/forums/sho...47&postcount=3
etc.

**Electroniktor** · 05/07/2007, 12h39

En fait si je comprend bien, dans un premier temps, on va coder une fonction qui récupère les dimensions de la console, qui les "analyse" pour calculer les diférentes coordonnées du terrain et pour finir qui créé et affiche ce terrain !!??

**Emmanuel Delahaye** · 05/07/2007, 12h46

Envoyé par Electroniktor

En fait si je comprend bien, dans un premier temps, on va coder une fonction qui récupère les dimensions de la console, qui les "analyse" pour calculer les diférentes coordonnées du terrain et pour finir qui créé et affiche ce terrain !!??

Oui, idem pour les raquettes, la balle...

**Electroniktor** · 05/07/2007, 13h17

Oui je veux bien essayer de faire ça

mais il va falloir me donner quelques pistes

!
Pour commencer, me montrer en pseudo-langage comment créer le terrain, et après si j'ai compris je pourrai me débrouiller avec la balle et les raquettes (enfin je pense !

) !

**Emmanuel Delahaye** · 05/07/2007, 13h24

Envoyé par Electroniktor

Oui je veux bien essayer de faire ça

mais il va falloir me donner quelques pistes

!
Pour commencer, me montrer en pseudo-langage comment créer le terrain, et après si j'ai compris je pourrai me débrouiller avec la balle et les raquettes (enfin je pense !

) !

Commence par lire ça

http://emmanuel-delahaye.developpez.com/tad.htm

parce qu'on va en bouffer !