flèches du clavier et séquence d'echappement

Version imprimable

13/06/2024, 09h19
emmesse

flèches du clavier et séquence d'echappement

Bonjour,

il me semble que les séquences d'échappement des flèches soient les suivantes:
haut: "^[[A"
bas: "^[[B"
gauche: "^[[D"
droite: "^[[C"

quelqu'un sait-il si ces séquence d'échappements sont bonnes et quel code il faut pour que l'appuie sur une flèche soit suffisant pour copier cette séquence vers une variable?
13/06/2024, 12h46
bacelar

Ça dépend du système, de comment il est configuré, voir du protocole réseau, si c'est un accès distant.
C'est quoi le "problème original" ?
13/06/2024, 14h24
emmesse

merci d'avoir répondu

système Linux, utf-8, local, déplacer un caractère en mode texte
13/06/2024, 14h26
emmesse

j'ai oublié de dire que c'est une variable dans un programme en c++
13/06/2024, 15h06
deedolith

Salut,

Il n'est pas possible de détecter les frappes au clavier de façon standard.
Il va te falloir passer par une librairie externe.

A ma connaissance, SFML propose quelque chose, mais c'est peut être overkill pour ton besoin.
Peut-être trouveras-tu ton bonheur ici: https://en.cppreference.com/w/cpp/links/libs

J'ai trouvé ça je ne sais plus où. À cette époque, on utilisait encore using namespace std.

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
#include <unistd.h>
#include <termios.h>
#include <cstdio>
#include <iostream>
#include <limits>
using namespace std;
 
 
char getch() {
  char buf = 0;
  struct termios old = {0};
  if (tcgetattr(0, &old) < 0)
    perror("tcsetattr()");
  old.c_lflag &= ~ICANON;
  old.c_lflag &= ~ECHO;
  old.c_cc[VMIN] = 1;
  old.c_cc[VTIME] = 0;
  if (tcsetattr(0, TCSANOW, &old) < 0)
    perror("tcsetattr ICANON");
  if (read(0, &buf, 1) < 0)
    perror ("read()");
  old.c_lflag |= ICANON;
  old.c_lflag |= ECHO;
  if (tcsetattr(0, TCSADRAIN, &old) < 0)
    perror ("tcsetattr ~ICANON");
  return (buf);
}

en utilisant ce getch, je m'en suis sorti comme ça:

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
#include <iostream>
 
char getch();
 
int main(){
  while(true){
    int c;
    c=getch();
    if(c==27){
      c=getch();
      if(c==91){
	c=getch();
	switch(c){
	case 65:
	  std::cout<<"haut"<<std::endl;
	  break;
	case 66:
	  std::cout<<"bas"<<std::endl;
	  break;
	case 67:
	  std::cout<<"droite"<<std::endl;
	  break;
	case 68:
	  std::cout<<"gauche"<<std::endl;
	}
      }
    }
  }
}

quelqu'un pourrait-il réécrire getch avec les std aux bons endroits?

13/06/2024, 19h14
Bousk

Typiquement le genre de trucs très hacky en consoles et qui prend quelques lignes avec une vraie fenêtre comme SFML pourrait fournir.

Citation:

quelqu'un pourrait-il réécrire getch avec les std aux bons endroits?

Tu supprimes using namespace std; et corriges les erreurs de compilation. :weird:
13/06/2024, 20h48
emmesse

Citation:

Envoyé par Bousk

Typiquement le genre de trucs très hacky en consoles et qui prend quelques lignes avec une vraie fenêtre comme SFML pourrait fournir.

désolé, je ne connais pas encore, mais ça va venir, la programmation évènementielle.

on peut supprimer usign..., apparemment on en a pas besoin.

sujet résolu
13/06/2024, 22h54
jo_link_noir

Citation:

Envoyé par emmesse

il me semble que les séquences d'échappement des flèches soient les suivantes:
haut: "^[[A"
bas: "^[[B"
gauche: "^[[D"
droite: "^[[C"

Les séquences ici représentent ce qui est affiché, pas les valeurs réellement utilisées. ^[ représente le caractère d'échappement (0x1b) qui est un caractère invisible. D'ailleurs, toutes les séquences de commande commence par ce caractère (que se soit les inputs clavier/souris ou celle interprétés par le terminal). Donc "haut" correspond à "\x1b[D". Le mieux est d'utiliser showkey -a pour visualiser correctement les séquences.

La bibliothèque standard ne fournit aucune facilité car elle est agnostique au système. Les séquences ANSI comme ici viennent essentiellement du monde UNIX.

Au passage, enlever / remettre en boucle le mode canonique comme le fait getch n'est pas terrible. Il faudrait plutôt l'enlever quand il y en a besoin et le remettre ensuite. Sinon, en général, quand on fait une TUI, on passe par des bibliothèques comme ncurses ou pdcurses.
14/06/2024, 15h12
emmesse

oui, j'avais remarqué pour les séquence. J'utilise la séquence 27,91,65 pour haut; 27,91,66 pour bas; 27,91,68 pour gauche et 27,91,67pour droite.
Je ne connaissais pas pdcurses, je verrais si il y a un tuto pour ça et je me documenterais.
Je ne connais absolument rien sur ce getch, j'ai trouvé ça sur internet il y a longtemps, je ne sais pas comment il fonctionne.
Merci pour showkey -a, c'est super!
15/06/2024, 13h17
LittleWhite

Bonjour,

Je rejoins emmesse, il faut passer en mode brut : https://c.developpez.com/faq/?page=G...mode-brut-UNIX
Sinon, il y a ncurses (pdcurses, c'est le portage pour Windows). Mais, ça permet de faire des choses plus jolis (ncurses, c'est les interfaces avec des cadres et une interface utilisateur, tout dans le terminal).
15/06/2024, 16h48
emmesse

merci LittleWhite de me rejoindre

c'est pas du C tout ça?

il existe ncurses pour c++?

que pensez-vous de SDL2?
15/06/2024, 17h09
kaitlyn

Salut,

Citation:

Envoyé par LittleWhite

Sinon, il y a ncurses (pdcurses, c'est le portage pour Windows)

Pour info, ncurses fonctionne très bien sous Windows.
15/06/2024, 17h13
emmesse

y a-t-il la même chose pour le C++?
15/06/2024, 17h15
kaitlyn

Oui, pour ncurses, dans un des sous-dossiers, il y a un wrapper c++.
15/06/2024, 17h17
emmesse

excuse-moi de continuer, mais as-tu une URL?
15/06/2024, 17h21
kaitlyn

Oui, le site officiel https://invisible-island.net/archives/ncurses/
15/06/2024, 18h02
emmesse
cool, ça a bien compilé
j'ai utlisé DESTDIR=... pour faire un paquet car c'est plus propre
Code:

1 2 3 4 5 $ configure --with-cxx --prefix /usr $ make $ make DESTDIR=/un/chemin install $ ls /un/chemin usr
15/06/2024, 18h54
kaitlyn

Je ne sais pas ce que tu cherches à faire exactement, ce lien peut être utile https://viewsourcecode.org/snaptoken...ngRawMode.html , et il y a pas mal de Libs très légères sur GitHub qui ne font que de la capture (raw input).
15/06/2024, 19h02
emmesse

le but final est de générer un labyrinthe, permettre d'y jouer et indiquer la solution. Je connais l'un des algorithmes pour en générer, je l'ai déjà fait en C, maintenant je voudrais le faire en C++.
15/06/2024, 19h31
kaitlyn

Il fallait commencer par ça. Oublie ncurses et prends SDL2 ou équivalent.

Edit:

https://www.studyplan.dev/sdl-dev/sdl2-window
15/06/2024, 19h41
emmesse

Merci pour l'URL, je vais voir ça.

1 pièce(s) jointe(s)

J'ai fini la première étape, la génération de labyrinthe:
Pièce jointe 656264

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
//classesEtConstantes.hpp
#ifndef CLASSESETCONSTANTES_HPP
#define CLASSESETCONSTANTES_HPP
 
#include <SDL2/SDL.h>
#include <random>
 
constexpr int largeur=24;
constexpr int hauteur=16;
 
struct lieu{
  lieu();
  bool mur_nord,mur_sud,mur_est,mur_ouest,chemin,non_marque;
};
 
class laby{
public:
  laby();
  void afficher(SDL_Renderer*);
  void boucle_de_jeu();
  void solution();
private:
  lieu tableau[largeur][hauteur];
  void creuser(int x,int y);
};
 
#endif

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
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
#include <iostream>
#include <random>
#include <SDL2/SDL.h>
#include "classesEtConstantes.hpp"
 
laby::laby(){
  creuser(0,0);//(0,0)=lieu de départ pour la construction
}
 
 
void laby::afficher(SDL_Renderer *pRenderer){
  char disque[3]={(char)226,(char)143,(char)186};
  SDL_Rect bords;
  bords.x=0;
  bords.y=0;
  bords.w=800;
  bords.h=600;
  SDL_SetRenderDrawColor(pRenderer,255,255,255,255);
  SDL_RenderFillRect(pRenderer,&bords);
  SDL_SetRenderDrawColor(pRenderer,0,0,0,255);
  bords.x=400-largeur*30/2;
  bords.y=300-hauteur*30/2;
  bords.w=largeur*30;
  bords.h=hauteur*30;
  SDL_RenderDrawRect(pRenderer,&bords);
  int width=largeur*30;
  int height=hauteur*30;
  for(int x=0;x<largeur;x++)
    for(int y=0;y<hauteur;y++){
      int X0=400-width/2+x*30;//X0 est l'abcisse du bord gauche du lieu courant
      int X1=400-width/2+(x+1)*30;//X1 est l'abcisse du bord droit du lieu courant
      int Y0=y*30+300-height/2;//Y0 est l'ordonnée du bord haut du lieu courant
      int Y1=(y+1)*30+300-height/2;//Y1 est l'ordonnée du bord bas du lieu courant
      if(tableau[x][y].mur_sud)
	SDL_RenderDrawLine(pRenderer,X0,Y1,X1,Y1);
      if(tableau[x][y].mur_est)
	SDL_RenderDrawLine(pRenderer,X1,Y0,X1,Y1);
    }
}
 
void laby::creuser(int x,int y){
  std::random_device rd;
  std::mt19937 eng(rd());
  std::uniform_int_distribution<int> distr2(0,1);
  std::uniform_int_distribution<int> distr3(0,2);
  std::uniform_int_distribution<int> distr4(0,3);
 
  tableau[x][y].non_marque=false;//pour marquer le lieu de coordonnées (x,y)
 
  if(x==0){//colonne ouest du tableau
    if(y==0){//coin nord-ouest du tableau
      while(tableau[x+1][y].non_marque||tableau[x][y+1].non_marque){
	switch(distr2(eng)){//abattre mur à l'est ou sud
	case 0://sud
	  if(tableau[x][y+1].non_marque){//lieu sud non marqué. il y a alors forcément mur_sud==true
	    tableau[x][y].mur_sud=tableau[x][y+1].mur_nord=false;//abattre mur sud
	    creuser(x,y+1);//creuser au sud
	  }
	  break;
	case 1://est
	  if(tableau[x+1][y].non_marque){//lieu est (point cardinal est) non marqué. il y a alors forcément mur_est==true
	    tableau[x][y].mur_est = tableau[x+1][y].mur_ouest = false; //abattre mur est (point cardinal est) 
	    creuser(x+1,y);//creuser à l'est
	  }
	}
      }
    }
    else if(y==hauteur-1){//coin sud-ouest du tableau
      while(tableau[x][y-1].non_marque||tableau[x+1][y].non_marque){
	switch(distr2(eng)){//abattre mur est (point cardinal est)  ou nord
	case 0://est
	  if(tableau[x+1][y].non_marque){//lieu est (point cardinal est) non marqué. il y a alors forcément mur_est==true
	    tableau[x][y].mur_est = tableau[x+1][y].mur_ouest = false; //abattre mur à l'est
	    creuser(x+1,y);//creuser à l'est
	  }
	  break;
	case 1://nord
	  if(tableau[x][y-1].non_marque){ //lieu nord non marqué. il y a alors forcément mur_nord==true
	    tableau[x][y].mur_nord = tableau[x][y-1].mur_sud=false; //abattre mur au nord
	    creuser(x,y-1);//creuser au nord
	  }
	}
      }
    }
    else{ //bord ouest du tableau
      while(tableau[x+1][y].non_marque||tableau[x][y-1].non_marque||tableau[x][y+1].non_marque){
	switch(distr3(eng)){
	case 0://est
	  if(tableau[x+1][y].non_marque){//lieu est (point cardinal est) non marqué. il y a alors forcément mur_est==true
	    tableau[x][y].mur_est = tableau[x+1][y].mur_ouest = false;
	    creuser(x+1,y);//creuser à l'est
	  }
	  break;
	case 1://nord
	  if(tableau[x][y-1].non_marque){ //lieu nord non marqué. il y a alors forcément mur_nord==true
	    tableau[x][y].mur_nord = tableau[x][y-1].mur_sud=false; //abattre mur au nord
	    creuser(x,y-1);//creuser au nord
	  }
	  break;
	case 2://sud
	  if(tableau[x][y+1].non_marque){//lieu sud non marqué. il y a alors forcément mur_sud==true
	    tableau[x][y].mur_sud=tableau[x][y+1].mur_nord=false;//abattre mur sud
	    creuser(x,y+1);//creuser au sud
	  }
	}
      }
    }
  }
  else if(x==largeur-1){//colonne est (point cardinal est) du tableau
    if(y==0){//coin nord-est du tableau
      while(tableau[x-1][y].non_marque||tableau[x][y+1].non_marque){
	switch(distr2(eng)){
	case 0://ouest
	  if(tableau[x-1][y].non_marque){//lieu ouest non marque. il y a alors forcément mur_ouest==true
	    tableau[x][y].mur_ouest=tableau[x-1][y].mur_est=false;//abattre mur_ouest
	    creuser(x-1,y);//creuser à l'ouest
	  }
	  break;
	case 1://sud
	  if(tableau[x][y+1].non_marque){//lieu sud non marqué. il y a alors forcément mur_sud==true
	    tableau[x][y].mur_sud=tableau[x][y+1].mur_nord=false;//abattre mur sud
	    creuser(x,y+1);//creuser au sud
	  }
	}
      }
    }
    else if(y==hauteur-1){//coin sud-est du tableau
      while(tableau[x][y-1].non_marque||tableau[x-1][y].non_marque){
	switch(distr2(eng)){
	case 0://nord
	  if(tableau[x][y-1].non_marque){ //lieu nord non marqué. il y a alors forcément mur_nord==true
	    tableau[x][y].mur_nord = tableau[x][y-1].mur_sud=false; //abattre mur au nord
	    creuser(x,y-1);//creuser au nord
	  }
	  break;
	case 1://ouest
	  if(tableau[x-1][y].non_marque){//lieu ouest non marque. il y a alors forcément mur_ouest==true
	    tableau[x][y].mur_ouest=tableau[x-1][y].mur_est=false;//abattre mur_ouest
	    creuser(x-1,y);//creuser à l'ouest
	  }
	}
      }
    }
    else{ //bord est du tableau
      while(tableau[x][y-1].non_marque||tableau[x-1][y].non_marque||tableau[x][y+1].non_marque){
	switch(distr3(eng)){
	case 0://nord
	  if(tableau[x][y-1].non_marque){ //lieu nord non marqué. il y a alors forcément mur_nord==true
	    tableau[x][y].mur_nord = tableau[x][y-1].mur_sud=false; //abattre mur au nord
	    creuser(x,y-1);//creuser au nord
	  }
	  break;
	case 1://ouest
	  if(tableau[x-1][y].non_marque){//lieu ouest non marque. il y a alors forcément mur_ouest==true
	    tableau[x][y].mur_ouest=tableau[x-1][y].mur_est=false;//abattre mur_ouest
	    creuser(x-1,y);//creuser à l'ouest
	  }
	  break;
	case 2://sud
	  if(tableau[x][y+1].non_marque){//lieu sud non marqué. il y a alors forcément mur_sud==true
	    tableau[x][y].mur_sud=tableau[x][y+1].mur_nord=false;//abattre mur sud
	    creuser(x,y+1);//creuser au sud
	  }
	}
      }
    }
  }
  else{//les autres abcisses
    if(y==0){//bord nord
      while(tableau[x-1][y].non_marque||tableau[x][y+1].non_marque||tableau[x+1][y].non_marque){
	switch(distr3(eng)){
	case 0://ouest
	  if(tableau[x-1][y].non_marque){//lieu ouest non marque. il y a alors forcément mur_ouest==true
	    tableau[x][y].mur_ouest=tableau[x-1][y].mur_est=false;//abattre mur_ouest
	    creuser(x-1,y);//creuser à l'ouest
	  }
	  break;
	case 1://sud
	  if(tableau[x][y+1].non_marque){//lieu sud non marqué. il y a alors forcément mur_sud==true
	    tableau[x][y].mur_sud=tableau[x][y+1].mur_nord=false;//abattre mur sud
	    creuser(x,y+1);//creuser au sud
	  }
	  break;
	case 2://est
	  if(tableau[x+1][y].non_marque){//lieu est (point cardinal est) non marqué. il y a alors forcément mur_est==true
	    tableau[x][y].mur_est = tableau[x+1][y].mur_ouest = false;
	    creuser(x+1,y);//creuser à l'est
	  }
	}
      }
    }
    else if(y==hauteur-1){//bord sud
      while(tableau[x-1][y].non_marque||tableau[x][y-1].non_marque||tableau[x+1][y].non_marque){
	switch(distr3(eng)){
	case 0://ouest
	  if(tableau[x-1][y].non_marque){//lieu ouest non marque. il y a alors forcément mur_ouest==true
	    tableau[x][y].mur_ouest=tableau[x-1][y].mur_est=false;//abattre mur_ouest
	    creuser(x-1,y);//creuser à l'ouest
	  }
	  break;
	case 1://nord
	  if(tableau[x][y-1].non_marque){ //lieu nord non marqué. il y a alors forcément mur_nord==true
	    tableau[x][y].mur_nord = tableau[x][y-1].mur_sud=false; //abattre mur au nord
	    creuser(x,y-1);//creuser au nord
	  }
	  break;
	case 2://est
	  if(tableau[x+1][y].non_marque){//lieu est (point cardinal est) non marqué. il y a alors forcément mur_est==true
	    tableau[x][y].mur_est = tableau[x+1][y].mur_ouest = false;
	    creuser(x+1,y);//creuser à l'est
	  }
	}
      }
    }
    else{ //autres ordonnées
      while(tableau[x][y-1].non_marque||tableau[x+1][y].non_marque||tableau[x][y+1].non_marque||tableau[x-1][y].non_marque){
	switch(distr4(eng)){
	case 0://nord
	  if(tableau[x][y-1].non_marque){ //lieu nord non marqué. il y a alors forcément mur_nord==true
	    tableau[x][y].mur_nord = tableau[x][y-1].mur_sud=false; //abattre mur au nord
	    creuser(x,y-1);//creuser au nord
	  }
	  break;
	case 1://est
	  if(tableau[x+1][y].non_marque){//lieu est (point cardinal est) non marqué. il y a alors forcément mur_est==true
	    tableau[x][y].mur_est = tableau[x+1][y].mur_ouest = false;
	    creuser(x+1,y);//creuser à l'est
	  }
	  break;
	case 2://sud
	  if(tableau[x][y+1].non_marque){//lieu sud non marqué. il y a alors forcément mur_sud==true
	    tableau[x][y].mur_sud=tableau[x][y+1].mur_nord=false;//abattre mur sud
	    creuser(x,y+1);//creuser au sud
	  }
	  break;
	case 3://ouest
	  if(tableau[x-1][y].non_marque){//lieu ouest non marque. il y a alors forcément mur_ouest==true
	    tableau[x][y].mur_ouest=tableau[x-1][y].mur_est=false;//abattre mur_ouest
	    creuser(x-1,y);//creuser à l'ouest
	  }
	}
      }
    }
  }
}

Code:

1
2
3
4
5
6
#include "classesEtConstantes.hpp"
 
lieu::lieu(){
  mur_nord = mur_sud = mur_est = mur_ouest = non_marque = true;
  chemin=false;
}

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
//main.cpp
#include <SDL2/SDL.h>
#include "classesEtConstantes.hpp"
 
int main(){
  laby labyrinthe;
  if (SDL_Init(SDL_INIT_EVERYTHING) < 0){
    SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "[DEBUG] > %s", SDL_GetError());
    return -1;
  }
  SDL_Window* pWindow{ nullptr };     
  SDL_Renderer* pRenderer{ nullptr };
  if (SDL_CreateWindowAndRenderer(800, 600, SDL_WINDOW_SHOWN, &pWindow, &pRenderer) < 0){
    SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "[DEBUG] > %s", SDL_GetError());        
    SDL_Quit(); 
    return -1;
  }
  SDL_Event events;
  bool isOpen{ true };
  while (isOpen){
    while (SDL_PollEvent(&events)){
      switch (events.type){
      case SDL_QUIT:
	isOpen = false;
	break;
      }
    }
    labyrinthe.afficher(pRenderer);
    SDL_RenderPresent(pRenderer);
  }
 
  SDL_DestroyRenderer(pRenderer);SDL_DestroyWindow(pWindow);
  SDL_Quit();
  return 0;
}

20/06/2024, 09h24
deedolith

Maintenant si tu veux faire du vrai C++ (sans tous ces pointeurs nu problématiques),
réécrit la même chose avec une bibliothèque C++.
20/06/2024, 11h04
emmesse

avec sfml peut-être?
que penses-tu de Qt?
20/06/2024, 17h34
kaitlyn

Salut,

Citation:

Envoyé par deedolith

Maintenant si tu veux faire du vrai C++ (sans tous ces pointeurs nu problématiques),
réécrit la même chose avec une bibliothèque C++.

Je ne partage pas du tout ton avis. Ce n'est pas en utilisant une Lib C++ qu'une personne se mettra soudainement à écrire du bon C++, et encore moins du vrai C++, parce que ça, je ne sais pas ce que c'est.
Je prends en exemple, freetype, ou sqlite ou autre Lib C utilisée pratiquement partout, alors non seulement c'est du C, très souvent du C89, mais en plus il y est fait énormément usage de PIMPL, de fonction-macros, du coup le style d'utilisation t'est pratiquement imposé. Dans ces cas là, tout ce que tu peux faire c'est de la ségrégation de code, mais ça n'empêchera pas d'écrire du bon C++ si tu en as la capacité.
20/06/2024, 19h40
deedolith

Je ne vais pas te contredire.

Cependant, quand on part de zéro, et qu'on a le choix, mieux vaut se tourner vers les bibliothèques C++.

Il y a aussi la possibilité d'écrire des wrappers, mais ce n'est pas à la portée de tous.
21/06/2024, 19h42
kaitlyn

Salut,

Le monde du jeu vidéo est beaucoup trop particulier et va bien au-delà de ces considérations. Tout ce que tu peux estimer comme vrai en applicatif ne l'est plus. Bien sûr, ce n'est pas avec un "snake game" que tu verras la différence.