Discussion :

[Electroniktor]

Bonjour à tous !

Je voudrais coder un petit jeu de tennis en C et en mode console.
Mais avant de me lancer dans le jeu lui même, j'ai voulu vérifier que cela était possible, mais je suis déjà confronté à un problème : le joueur ne peut déplacer la raquette qu'au rythme de la balle ... et cela est un peu gênant.
Je n'ai trouvé aucune solution, alors si quelqu'un en a une ...

Cordialement.

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
#include <stdio.h>
#include <stdlib.h>
#include <conio2.h>
#include <windows.h>
#include "affichage.h"
 
int main(int argc, char *argv[])
{
    long x_raquette = 19;
 
    long y_raquette1 = 9;
 
    long y_raquette2 = 10;
 
    long y_raquette3 = 11;
 
    long x_balle = 40;
    long y_balle = 14;
 
    long toucheAppuyee = '0';
 
    char raquette_1 = '|';
    char raquette_2 = '|';
    char raquette_3 = '|';
 
    titre();
    terrain();
 
    do
    {
      gotoxy (x_raquette, y_raquette1);
      printf("%c", raquette_1);
 
      gotoxy (x_raquette, y_raquette2);
      printf("%c", raquette_2);
 
      gotoxy (x_raquette, y_raquette3);
      printf("%c", raquette_3);
 
      gotoxy( x_balle, y_balle);
      putch(' ');
 
      x_balle--;
 
      gotoxy( x_balle, y_balle);
      putch('o');
      sleep(300);  
 
      if (kbhit ())
      {
                toucheAppuyee = getch();
                if (toucheAppuyee == '8' && y_raquette1 != 7)
                {
                                  y_raquette1--;
                                  y_raquette2--;
                                  y_raquette3--;
 
                                  gotoxy( x_raquette, y_raquette3 + 1);
                                  putch(' ');
                }
 
                if (toucheAppuyee == '2' && y_raquette3 != 21)
                {
                                  y_raquette1++;
                                  y_raquette2++;
                                  y_raquette3++;
 
                                  gotoxy( x_raquette, y_raquette1 - 1);
                                  putch(' ');
                }
      }
 
     } while (x_balle != x_raquette + 1);
 
 
  getch();      
  return 0;
}

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
#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()
 
{ 
     printf("\n\n\n");
     printf("\t\t+-----------------------+-----------------------+\n");
     printf("\t\t|                       |                       |\n");
     printf("\t\t|                       |                       |\n");
     printf("\t\t|                       |                       |\n");
     printf("\t\t|                       |                       |\n");
     printf("\t\t|                       |                       |\n");
     printf("\t\t|                       |                       |\n");
     printf("\t\t|                       |                       |\n");
     printf("\t\t|                       |                       |\n");
     printf("\t\t|                       |                       |\n");
     printf("\t\t|                       |                       |\n");
     printf("\t\t|                       |                       |\n");
     printf("\t\t|                       |                       |\n");
     printf("\t\t|                       |                       |\n");
     printf("\t\t|                       |                       |\n");
     printf("\t\t|                       |                       |\n");
     printf("\t\t+-----------------------+-----------------------+");  
}

affichage.h :

Code :

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

1
2
void titre();
void terrain();

[Electroniktor]

Personne n'a de solution ???
Ou au moins pour faire en sorte que lorsque le joueur appuie 5 fois sur 8 et que le rythme de la balle oblige la raquette a ne se déplacer que de 3 mesures, lorsque le joueur appuie sur 2, le programme fasse descendre la raquette immédiatement et n'attende pas que les 5 entrées soient traitées.
Si vous ne voyez pas ce que je veux dire, compilez mon code et appuiez 5 fois sur le 8 et tout de suite après 1 fois sur le 2 et vous comprendrez !

[souviron34]

d'abord dans tes :

Code :

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

1
2
 
                if (toucheAppuyee == '8' && y_raquette1 != 7)

tu ferais mieux de mettre des else ...

Parce que dans chaque cas tu modifies les valeurs sur lesqelles tu testes....

[Electroniktor]

Oui mais si après je ne met pas :

Code :

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

if (toucheAppuyee == '2' && y_raquette3 != 21)

je peux faire descendre la raquette en appuyant sur n'importe quelle touche (et cela est très gênant d'autant plus qu'après il y aura une touche pour mettre la balle en jeu, une pour mettre pause, une pour quitter ...) !

[frp31]

je vais probablement dire une betise ou etre tres incomplet
mais pour faire plusieurs taches a la fois ne suffit t il pas de laisser le systeme gerer ca ? en creant un processus fils pour gerer la balle ?

ainsi le systeme se debrouille pour gere les processus ton programme n'a qu'a verifier les coordonnees de la balle et des raquettes et le clavier sur 3 processus

il integrera ainsi ces processus dans les files d'attende du multithread

probablement en utilisant l'include <unistd.h>
et des pid=fork();
des waitpid(pid,&etat,WUNTRACED)

etc... pour gerer les differents processus ...

mais bon la faudrai demander a plus expert que moi de te donner un exemple concret.

[Electroniktor]

Oui mais si j'utilise une FIFO, il faut bien que je la boucle ?!
Et je ne peux pas mettre une boucle à l'interrieur d'une autre ?!
Enfin ce n'est qu'une supposition, dites-moi si je me trompe ?!

Sinon on m'a conseillé de vider le buffer du clavier après chaque entrée pour résoudre ma seconde proposition. J'ai donc trouvé ce code et je suis en train d'essayé de l'intègrer à l'autre :

Code :

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

1
2
3
4
#include <stdio.h>
 
int c;
while ((c = getchar()) != '\n' && c != EOF);

[Emmanuel Delahaye]

Sinon on m'a conseillé de vider le buffer du clavier après chaque entrée pour résoudre ma seconde proposition. J'ai donc trouvé ce code et je suis en train d'essayé de l'intègrer à l'autre :

Code :

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

1
2
3
4
#include <stdio.h>
 
int c;
while ((c = getchar()) != '\n' && c != EOF);

Il est impossible de faire un jeu réactif avec les fonctions d'E/S standard ni même conio et autre getch() ou kbhit() (pas de gestion de la répétition). Je te conseille la bibliothèque SDL qui est faite pour ça.

[BS_C3]

Bonjour,

Moi j'avais fait un space invaders avec le même problème. Mon joueur ne pouvait tirer qu'au rythme de deplacement des navettes ennemies...
J'ai du faire un compteur de temps. Je m'explique...
Le main qui gérait le jeu était construit en fonction du déplacement du joueur et ses fonctions de tir. Les navettes devaient se déplacer toutes les x temps. S'il y avait déplacement, tir ou rien, je vérifiais si le compteur avait atteint les x temps imposés pour faire bouger les navettes. Si oui, les navettes bougeaient. Si non, le personnage bougeait, ou le tir était effectué. Chaque élément de mon jeu avait un chronomètre. A la fin, les navettes pouvaient tirer sur le joueur, détruire des blocs de protection, détruire le personnage ou viceversa. Le joueur pouvait tirer sur les navettes, les detruire ou détruire ses propres blocs de protection.

Je ne sais pas si j'ai été assez claire. Mais si tu veux, je peux t'envoyer le code de mon space invaders si ça peux te servir (Meme s'il est un peu pauvre niveau graphique )

[Electroniktor]

En fait si j'ai bien compris , un chronomètre compte le temps. A chaque fois que le joueur appuie sur une touche pour effectuer une action, le temps chronomètré est comparé à celui imposé pour que la navette bouge. Si le temps est supérieur à celui imposé, la navette bouge et l'action est effectué et si le temps est inférieur, seulement l'action est effectuée ?!
Mais post ton code (ou envoie le moi par MP) pour voir si j'ai bien compris !

[Electroniktor]

Tu m'as oublié BS_C3 ??!!

[Electroniktor]

Re !

Alors voilà j'ai fait une code qui reprend l'idée de BS_C3 (enfin je pense ). Il marche très bien et j'envisage de refaire le même mais avec l'obtension de la date avec une précision au millième de seconde (si c'est possible !) .
Voilà mon code, si vous trouvez qu'on peut l'améliorer ou le simplifier, faite le savoir ...

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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio2.h>
#include <windows.h>
 
int main(void)
{
    long difference = 0;
    long etat = 0;
    long x_b = 30;
    long y_b = 10;
    long x_r = 10;
    long y_r = 10;
    long toucheAppuyee = '0';
 
    time_t depart;
    time_t courante;
 
    gotoxy (x_b, y_b);
    putch('o');
 
    gotoxy (x_r, y_r);
    putch('|');
 
    do
    {
         if (etat == 0)
         {    
         time(&depart);
         etat = 1;
         }
 
         time(&courante);
         difference = difftime(courante,depart);
 
         if (kbhit ())
         {
                   toucheAppuyee = getch();
 
                   if (toucheAppuyee == '2' && difference < 0.1)
                   {
                                     gotoxy( x_r, y_r);
                                     putch(' ');
                                     y_r++;
                                     gotoxy( x_r, y_r);
                                     putch('|');
                   }
 
                   if (toucheAppuyee == '8' && difference < 0.1)
                   {
                                     gotoxy( x_r, y_r);
                                     putch(' ');
                                     y_r--;
                                     gotoxy( x_r, y_r);
                                     putch('|');
                   }
 
         }
 
         if (difference > 0.1)
         {
         gotoxy( x_b, y_b);
         putch(' ');
         x_b--;
         gotoxy( x_b, y_b);
         putch('o');
         etat = 0;
         }        
     } while (x_b != x_r);
 
    getch();
    return 0;
}

[Emmanuel Delahaye]

Re !

Alors voilà j'ai fait une code qui reprend l'idée de BS_C3 (enfin je pense ). Il marche très bien et j'envisage de refaire le même mais avec l'obtension de la date avec une précision au millième de seconde (si c'est possible !) .
Voilà mon code, si vous trouvez qu'on peut l'améliorer ou le simplifier, faite le savoir ...

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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio2.h>
#include <windows.h>
 
int main(void)
{
    long difference = 0;
    long etat = 0;
    long x_b = 30;
    long y_b = 10;
    long x_r = 10;
    long y_r = 10;
    long toucheAppuyee = '0';
 
    time_t depart;
    time_t courante;
 
    gotoxy (x_b, y_b);
    putch('o');
 
    gotoxy (x_r, y_r);
    putch('|');
 
    do
    {
         if (etat == 0)
         {    
         time(&depart);
         etat = 1;
         }
 
         time(&courante);
         difference = difftime(courante,depart);
 
         if (kbhit ())
         {
                   toucheAppuyee = getch();
 
                   if (toucheAppuyee == '2' && difference < 0.1)
                   {
                                     gotoxy( x_r, y_r);
                                     putch(' ');
                                     y_r++;
                                     gotoxy( x_r, y_r);
                                     putch('|');
                   }
 
                   if (toucheAppuyee == '8' && difference < 0.1)
                   {
                                     gotoxy( x_r, y_r);
                                     putch(' ');
                                     y_r--;
                                     gotoxy( x_r, y_r);
                                     putch('|');
                   }
 
         }
 
         if (difference > 0.1)
         {
         gotoxy( x_b, y_b);
         putch(' ');
         x_b--;
         gotoxy( x_b, y_b);
         putch('o');
         etat = 0;
         }        
     } while (x_b != x_r);
 
    getch();
    return 0;
}

Je pense que tu devrais déjà travailler sur le mouvement de la balle...un peu de reflexion et hop :

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
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio2.h>
 
#define MS(ms) (CLOCKS_PER_SEC / (1000.0 / (ms)))
 
#define X_MIN  1
#define X_MAX  80
#define Y_MIN  1
#define Y_MAX  25
 
enum dir
{ NW, NE, SE, SW };
 
struct ball
{
   int x;
   int y;
   enum dir dir;
};
 
struct plot
{
   int x;
   int y;
};
 
static void move_ball (struct ball *this)
{
   gotoxy (this->x, this->y), putch (' ');
   switch (this->dir)
   {
   case NW:
      this->x--;
      this->y--;
 
      if (this->x == X_MIN && this->y == Y_MIN)
      {
         this->dir = SE;
         this->x++;
         this->y++;
      }
      else if (this->x == X_MIN)
      {
         this->dir = NE;
         this->x++;
      }
      else if (this->y == Y_MIN)
      {
         this->dir = SW;
         this->y++;
      }
      break;
 
   case NE:
      this->x++;
      this->y--;
 
      if (this->x == X_MAX && this->y == Y_MIN)
      {
         this->dir = SW;
         this->x--;
         this->y++;
      }
      else if (this->x == X_MAX)
      {
         this->dir = NW;
         this->x--;
      }
      else if (this->y == Y_MIN)
      {
         this->dir = SE;
         this->y++;
      }
      break;
 
   case SE:
      this->x++;
      this->y++;
 
      if (this->x == X_MAX && this->y == Y_MAX)
      {
         this->dir = NW;
         this->x--;
         this->y--;
      }
      else if (this->x == X_MAX)
      {
         this->dir = SW;
         this->x--;
      }
      else if (this->y == Y_MAX)
      {
         this->dir = NE;
         this->y--;
      }
      break;
 
   case SW:
      this->x--;
      this->y++;
 
      if (this->x == X_MIN && this->y == Y_MAX)
      {
         this->dir = NE;
         this->x++;
         this->y--;
      }
      else if (this->x == X_MIN)
      {
         this->dir = SE;
         this->x++;
      }
      else if (this->y == Y_MAX)
      {
         this->dir = NW;
         this->y--;
      }
      break;
   }
   gotoxy (this->x, this->y), putch ('o');
}
 
static void move_plot (struct plot *this)
{
}
 
int main (void)
{
   int end = 0;
   struct ball ball = { 40, 12, NW };
   struct plot plot = { 1, 12 };
   clock_t echeance = clock () + MS(100);
 
   gotoxy (ball.x, ball.y), putch ('o');
 
   while (!end)
   {
      if (clock () > echeance)
      {
         move_ball (&ball);
         echeance = clock () + MS(100);
      }
      if (kbhit ())
      {
         int c = getch ();
         switch (c)
         {
         case '2':
         case '8':
            move_plot (&plot);
            break;
         case 27:
            end = 1;
         }
      }
   }
   return 0;
}

Pose des questions si tu ne comprends pas...

[Electroniktor]

Salut !

Merci beaucoup pour le code que tu as fournit . Je l'ai très bien compris (bien que j'aurais été incapable d'en faire autant ! ) et je vais essayé de complèter la fonction move_plot ainsi que le main.

PS : pourquoi utilises-tu des this partout ?

Je posterai ma solution et les difficultés si j'en ai ! Et merci encore merci !

[Emmanuel Delahaye]

PS : pourquoi utilises-tu des this partout ?

Parce que c'est le pointeur de contexte...

Au fait, ce code (le mien) est horrible, parce qu'il consomme 100% du CPU. Il faudrait ajouter un Sleep(1) (Windows, soit une pause de 1 ms) dans la boucle principale pour redonner la main au système régulièrement...

[souviron34]

faudrait ajouter un Sleep(1) (Windows, soit une pause de 1 ms)

juste une tite note pour ceux qui connaissent pas... sleep(1) sous unixoide est une pause de 1 seconde...

[Electroniktor]

Bon ben voilà je suis déjà confronté à un problème : dans ta boucle principale, tu mets un switch sur c. Dans ce switch, tu fait appel à la fonction move_plot. Cela veut dire que dans cette fonction, il faut aussi que je fasse un switch, mais un switch sur quoi ? Je ne peux pas le faire sur c ?! A moins que je fasse une fonction pour chaque case mais je pense pas que c'est ce que tu pensais faire ...

[Emmanuel Delahaye]

dans ta boucle principale, tu mets un switch sur c. Dans ce switch, tu fait appel à la fonction move_plot. Cela veut dire que dans cette fonction, il faut aussi que je fasse un switch, mais un switch sur quoi ? Je ne peux pas le faire sur c ?!

Pourquoi ? J'ai oublié de le passer en paramètre ? Qu'à cela ne tienne :

Code :

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

1
2
3
4
5
 
static void move_plot (struct plot *this, int c)
{
   /* ... */
}

[Electroniktor]

Alors voilà ce que j'ai fait. Cela compile bien et s'execute mais le problème est qu'iil y a un getch() en trop et je ne sais pas où il faut que j'en enlève un !

La 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
15
16
17
18
19
20
21
22
static void move_plot (struct plot *this, int c)
{
       c = getch();
       switch(c)
       {
                case '2':
                     gotoxy( this->x, this->y);
                     putch(' ');
                     this->y++;
                     gotoxy( this->x, this->y);
                     putch('|');
                     break;
 
                case '8':
                     gotoxy( this->x, this->y);
                     putch(' ');
                     this->y--;
                     gotoxy( this->x, this->y);
                     putch('|');
                     break;
       }
}

La boucle :

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
while (!end)
   {
      if (clock () > echeance)
      {
         move_ball (&ball);
         echeance = clock () + MS(100);
      }
      if (kbhit ())
      {
         int c = getch();
         switch (c)
         {
         case '2':
              move_plot (&plot, &c);
              break;
         case '8':
            move_plot (&plot, &c);
            break;
         case 27:
            end = 1;
            break;
         }
      }
   }

[Emmanuel Delahaye]

Alors voilà ce que j'ai fait. Cela compile bien et s'execute mais le problème est qu'iil y a un getch() en trop et je ne sais pas où il faut que j'en enlève un !

Code :

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

1
2
3
static void move_plot (struct plot *this, int c)
{
       c = getch();

A l'évidence, c'est celui-ci, puisque la valeur à traiter est déjà dans c... C'est pas évident ?

Tu as oublié de tester les limites (la raquette part dans le décor...)

ceci fonctionne :

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
 
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <conio2.h>
 
#define MS(ms) (CLOCKS_PER_SEC / (1000.0 / (ms)))
 
#define X_MIN  1
#define X_MAX  80
#define Y_MIN  1
#define Y_MAX  25
 
enum dir
{ NW, NE, SE, SW };
 
struct ball
{
   int x;
   int y;
   enum dir dir;
};
 
struct plot
{
   int x;
   int y;
};
 
static void move_ball (struct ball *this)
{
   gotoxy (this->x, this->y), putch (' ');
   switch (this->dir)
   {
   case NW:
      this->x--;
      this->y--;
 
      if (this->x == X_MIN && this->y == Y_MIN)
      {
         this->dir = SE;
         this->x++;
         this->y++;
      }
      else if (this->x == X_MIN)
      {
         this->dir = NE;
         this->x++;
      }
      else if (this->y == Y_MIN)
      {
         this->dir = SW;
         this->y++;
      }
      break;
 
   case NE:
      this->x++;
      this->y--;
 
      if (this->x == X_MAX && this->y == Y_MIN)
      {
         this->dir = SW;
         this->x--;
         this->y++;
      }
      else if (this->x == X_MAX)
      {
         this->dir = NW;
         this->x--;
      }
      else if (this->y == Y_MIN)
      {
         this->dir = SE;
         this->y++;
      }
      break;
 
   case SE:
      this->x++;
      this->y++;
 
      if (this->x == X_MAX && this->y == Y_MAX)
      {
         this->dir = NW;
         this->x--;
         this->y--;
      }
      else if (this->x == X_MAX)
      {
         this->dir = SW;
         this->x--;
      }
      else if (this->y == Y_MAX)
      {
         this->dir = NE;
         this->y--;
      }
      break;
 
   case SW:
      this->x--;
      this->y++;
 
      if (this->x == X_MIN && this->y == Y_MAX)
      {
         this->dir = NE;
         this->x++;
         this->y--;
      }
      else if (this->x == X_MIN)
      {
         this->dir = SE;
         this->x++;
      }
      else if (this->y == Y_MAX)
      {
         this->dir = NW;
         this->y--;
      }
      break;
   }
   gotoxy (this->x, this->y), putch ('o');
}
 
static void move_plot (struct plot *this, int c)
{
   switch (c)
   {
   case '2':
      if (this->y < Y_MAX)
      {
         gotoxy (this->x, this->y), putch (' ');
         this->y++;
         gotoxy (this->x, this->y), putch ('|');
      }
      break;
 
   case '8':
      if (this->y > Y_MIN)
      {
         gotoxy (this->x, this->y), putch (' ');
         this->y--;
         gotoxy (this->x, this->y), putch ('|');
      }
      break;
   }
}
 
int main (void)
{
   int end = 0;
   struct ball ball = { 40, 12, NW };
   struct plot plot = { 1, 12 };
   clock_t echeance = clock () + MS (100);
 
   /* positions initiales */
   gotoxy (ball.x, ball.y), putch ('o');
   gotoxy (plot.x, plot.y), putch ('|');
 
   /* mouvement */
   while (!end)
   {
      if (clock () > echeance)
      {
         move_ball (&ball);
         echeance = clock () + MS (100);
      }
      if (kbhit ())
      {
         int c = getch ();
         switch (c)
         {
         case '2':
         case '8':
            move_plot (&plot, c);
            break;
         case 27:
            end = 1;
         }
      }
   }
   return 0;
}

Evidemment, il faut modifier le déplacement de la balle pour que le renvoi ne se fasse que si la balle touche la raquette, sinon, c'est perdu (+1 pour l'adversaire). Il faudra donc probablement passer l'information 'plot' à move_ball()...

Nota : quand je fournis du code, il est écrit (présenté) selon un modèle bien précis. Tu ferais bien de t'en inspirer, ça éviterait ta présentation à la barbare...

[Electroniktor]

Si c'est évident, c'est même ce que j'ai fait en premier, mais si je supprime ce getch() , la raquette n'apparait plus .
Et il faut bien dire au programme la manière dont c est déterminé (là c'est grâce à la simple pression d'une touche sur la clavier, donc getch() ) ?!

EDIT : Désolé tu as édité ton message pendant que je faisait le mien !