Problème d'affichage continu

Version imprimable

23/02/2009, 11h50
Heezalive

Problème d'affichage continu

Bonjour à tous amis développeurs!! :D

Dans le but de réaliser un snake, je souhaite afficher une clôture pour délimiter le terrain. A l'intérieur de ce terrain se trouve mon snake qui se balade.
Le problème est que j'affiche puis j'efface en continu. Du coup ma clôture grésille. :(
Je me demandais donc s'il n'y avait pas moyen d'éliminer ce vieil effet (par exemple en figeant la clôture et en superposant le snake) sans bibliothèque graphique.

merci
23/02/2009, 12h01
souviron34
il y a plein de solutions..
- Avoir l'image de la barrière en image background
- Tout retracer dans l'ordre
- Tracer le snake en XOR
- Effacer et retracer juste le rectangle occupé par le snake
- ...
Mais ce n'est pas un problème de C...

Si si je t'assure que mon problème est bien résolvable en c mais je ne sais pas exactement comment. J'aimerai pouvoir superposer mes tableaux mais je ne sais pas comment faire. Pour plus de précisions voici mon code

il s'agit d'un seul tableau (pour l'instant) à deux dimensions avec une clôture en code ascii:

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
 
#include "snake.h"
 
int main()
{
  int i;
  int j;
  int posit_y=19;//vertical
  int posit_x=30;//horizontal
 
  char direction='d';
  char touche='f';
  char tete=16;
  char ring[40][60];
 
  for (i=0; i<40; i++)
  {
        for (j=0; j<60; j++)
        {
            ring[i][j]=' ';
        }
  }
 
  //clôture
  for(i=1;i<59;i++)
  {
        ring[0][i]=-51;
        ring[39][i]=-51;
  }
  for(j=1;j<39;j++)
  {
        ring[j][0]=-70;
        ring[j][59]=-70;
        // angles
        ring[39][0]=-56;
        ring[0][0]=-55;
        ring[0][59]=-69;
        ring[39][59]=-68;
  }
 
  while (touche!=27)// si l'utilisateur enfonce la touche echap
  {
 
     //placement
     ring[posit_y][posit_x]=tete;
 
     system("CLS");
     //affichage du tableau
     printf("\n\n\n\n\t");
     for (i=0; i<40; i++)
     {
        for (j=0; j<60; j++)
        {
            printf ("%c",ring [i][j]);
        }
     printf("\n\t");
     }
 
     //effacement
     ring[posit_y][posit_x]=15;
 
     if(kbhit())
     {
              touche=getch();
 
              switch(touche)
              {
                    case 'f':
                         if(direction!='g')
                         {
                             direction='d';
                         }
                         break;
                    case 'd':
                         if(direction!='h')
                         {
                             direction='b';
                         }
                         break;
                    case 's':
                         if(direction!='d')
                         {
                             direction='g';
                         }
                         break;
                    case 'e':
                         if(direction!='b')
                         {
                             direction='h';
                         }
                         break;
              }
     }
     switch(direction)
     {
        case 'd': // de gauche à droite
             posit_x++;
             tete=16;
             break;
 
        case 'b': //de haut en bas
            posit_y++;
            tete=31;
            break;
 
        case 'g': //de droite à gauche
           posit_x--;
           tete=17;
           break;
 
        case 'h': //de bas en haut
           posit_y--;
           tete=30;
           break;
     }
     // réapparition de l'autre coté de l'écran
     if(posit_x>58)
     {
                   posit_x=1;
     }
     else if(posit_x<1)
     {
                   posit_x=58;
     }
 
     if(posit_y>38)
     {
                   posit_y=1;
     }
     else if(posit_y<1)
     {
                   posit_y=38;
     }
  }
  system("PAUSE");	
  return 0;
}

Citation:

Envoyé par Heezalive

C'est un problème de conception. Ce qui est 'décor' doit être affiché une seule fois. Ensuite, dans la boucle, on ne traite que les mouvements et la détection des commandes clavier

Code:

1
2
3
4
5
6
7
8
9
 
BEGIN
 afficher_decor()
 DO
  suspension(T)
  deplacement()
  fin := traiter_clavier()
 WHILE NOT fin
END

Je t'engage à lire ceci :

http://delahaye.emmanuel.free.fr/spip.php?rubrique21

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

et à partir sur ces bases ...

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
 
#include <stdio.h>
#include <conio2.h>
 
/* http://delahaye.emmanuel.free.fr/clib/ */
#include "psleep/inc/psleep.h"
 
/* taille */
#define HAUT 20
#define LARG 60
 
/* positionnement */
#define X0 8
#define Y0 4
 
/* periode en ms */
#define T 300
 
struct jeu
{
   char ring[HAUT][LARG];
/* vertical */
   int posit_y;
/* horizontal */
   int posit_x;
 
   int tete;
   int direction;
 
};
 
static void afficher_decor (struct jeu *p)
{
 
   /* effacer la zone de jeu */
   {
      int i;
      for (i = 0; i < HAUT; i++)
      {
         int j;
         for (j = 0; j < LARG; j++)
         {
            p->ring[i][j] = ' ';
         }
      }
   }
 
   /* clôture */
 
   /* horizontales */
   {
      int j;
      for (j = 1; j < LARG - 1; j++)
      {
         p->ring[0][j] = -51;
         p->ring[HAUT - 1][j] = -51;
      }
   }
 
   /* verticales */
   {
      int i;
      for (i = 1; i < HAUT - 1; i++)
      {
         p->ring[i][0] = -70;
         p->ring[i][LARG - 1] = -70;
      }
   }
 
   /* angles */
   p->ring[0][0] = -55;
   p->ring[0][LARG - 1] = -69;
   p->ring[HAUT - 1][0] = -56;
   p->ring[HAUT - 1][LARG - 1] = -68;
 
/* affichage du tableau */
   clrscr ();
 
   {
      int i;
      for (i = 0; i < HAUT; i++)
      {
         int j;
         for (j = 0; j < LARG; j++)
         {
            gotoxy (X0 + j, Y0 + i);
            putch (p->ring[i][j]);
 
            gotoxy (70, 1);
            cprintf ("x=%02d y=%02d", X0 + j, Y0 + i);
 
         }
      }
   }
 
/* horizontal */
   p->posit_x = LARG / 2;
/* vertical */
   p->posit_y = HAUT / 2;
 
   p->tete = 16;
   p->direction = 'd';
 
/* affichage */
   gotoxy (X0 + p->posit_x, Y0 + p->posit_y);
   putch (p->tete);
 
}
 
static void suspension (int ms)
{
   msleep (ms);
}
 
static void deplacement (struct jeu *p)
{
/* effacement */
   gotoxy (X0 + p->posit_x, Y0 + p->posit_y);
   putch (' ');
 
/* deplacer */
   switch (p->direction)
   {
/* de gauche à droite */
   case 'd':
      p->posit_x++;
      if (p->posit_x > LARG - 2)
      {
         p->posit_x = 1;
      }
      p->tete = 16;
      break;
 
/* de haut en bas */
   case 'b':
      p->posit_y++;
      if (p->posit_y > HAUT - 2)
      {
         p->posit_y = 1;
      }
      p->tete = 31;
      break;
 
/* de droite à gauche */
   case 'g':
      p->posit_x--;
      if (p->posit_x < 1)
      {
         p->posit_x = LARG - 2;
      }
      p->tete = 17;
      break;
 
/* de bas en haut */
   case 'h':
      p->posit_y--;
      if (p->posit_y < 1)
      {
         p->posit_y = HAUT - 2;
      }
      p->tete = 30;
      break;
   }
 
/* affichage */
   gotoxy (X0 + p->posit_x, Y0 + p->posit_y);
   putch (p->tete);
 
}
 
static int traiter_clavier (struct jeu *p)
{
   int fin = 0;
 
   if (kbhit ())
   {
      int touche = getch ();
 
      switch (touche)
      {
      case 27:
         fin = 1;
         break;
      case 'f':
         if (p->direction != 'g')
         {
            p->direction = 'd';
         }
         break;
      case 'd':
         if (p->direction != 'h')
         {
            p->direction = 'b';
         }
         break;
      case 's':
         if (p->direction != 'd')
         {
            p->direction = 'g';
         }
         break;
      case 'e':
         if (p->direction != 'b')
         {
            p->direction = 'h';
         }
         break;
      }
   }
   return fin;
}
 
int main (void)
{
   struct jeu jeu;
   int fin;
 
   afficher_decor (&jeu);
   do
   {
      suspension (T);
      deplacement (&jeu);
      fin = traiter_clavier (&jeu);
   }
   while (!fin);
 
   return 0;
}

23/02/2009, 15h07
Heezalive

Problème d'affichage continu

Bien merci beaucoup... j'en ai pour un petit moment, je vais méditer là dessus.
23/02/2009, 23h20
Heezalive

problème de compilation

Ce que tu m'as indiqué m'a l'air fort intéressant mais quelque peu... compliqué.
J'ai récupéré le code que tu as fait j'ai téléchargé le devpack conio pour conio2.h, ajouté la bibliothèque psleep, ainsi que libconio.a au projet et le compilateur à l'air d'avoir du mal à me créer un .exe. Peut-être est-ce à cause de Dev C++ ??
Il me dit [Build Error] [snake.exe] Error 1
24/02/2009, 00h14
Heezalive

A ouiiiiiiii si ça marche trop bien!!! merci beaucoup!! :D je vais maintenant essayer de comprendre comment tu as fait!! :mrgreen: