diff --git a/#serpent.c# b/#serpent.c#
new file mode 100644
index 0000000..236c563
--- /dev/null
+++ b/#serpent.c#
@@ -0,0 +1,303 @@
+#include <stdlib.h>
+#include <graph.h>
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#define HAUTEUR 40
+#define LARGEUR 60
+#define TAILLE_CASE 19
+#define NOMBRE_POMMES 5
+#define CYCLE 100000L
+
+typedef struct {
+    int x;
+    int y;
+} Position;
+
+typedef struct {
+    Position* corps;
+    int longueur;
+} Serpent;
+
+typedef struct {
+    Position* positions;
+    int nombre;
+} Pommes;
+
+Serpent serpent;
+Pommes pommes;
+
+int score = 0;  
+int perdu = 0;
+
+void Attendre(unsigned int millisecondes) {
+  usleep(millisecondes * 1000);
+}
+
+void InitialiserJeu() {
+  serpent.longueur = 10;
+  serpent.corps = malloc(sizeof(Position) * serpent.longueur);
+  pommes.nombre = NOMBRE_POMMES;
+
+  srand(time(NULL));
+
+  serpent.corps[0].x = LARGEUR / 2 * TAILLE_CASE;
+  serpent.corps[0].y = HAUTEUR / 2 * TAILLE_CASE;
+  perdu = 0;  /* Initialisation de la variable perdu*/
+}
+
+void Graphique() {
+  InitialiserGraphique();
+  CreerFenetre(1, 1, 1240, 940);
+  EcrireTexte(500, 400, "Le jeu va commencer !", 2);
+  Attendre(1000);
+  EffacerEcran(CouleurParComposante(0, 0, 0));
+}
+
+void AffichageBasique() {
+  ChoisirCouleurDessin(CouleurParComposante(111, 255, 94));
+  RemplirRectangle(0, 0, 1140, 760);
+}
+
+void AfficherScore() {
+  char scoreText[20];  /* Correction de la taille du tableau*/
+  snprintf(scoreText, 20, "Score: %d", score);
+  ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
+  RemplirRectangle(20, 820, 150, 40);
+  ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
+  EcrireTexte(20, 850, scoreText, 2);
+}
+
+int PauseJeu() {
+  while (1) {
+    if (ToucheEnAttente()) {
+      int touche = Touche();
+      if (touche == XK_space) {
+	return 1;  /* La barre d'espace a été pressée, reprendre le jeu*/
+      }
+    }
+    Attendre(100);
+  }
+}
+
+void LibererMemoire() {
+  free(serpent.corps);
+  free(pommes.positions);
+}
+
+void AfficheTemps(int minute, int seconde) {
+  char temps[6];
+  snprintf(temps, 6, "%02d:%02d", minute, seconde);
+  ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
+  RemplirRectangle(20, 870, 70, 40);
+  ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
+  EcrireTexte(20, 900, temps, 2);
+}
+
+void AfficherSerpent() {
+  couleur couleurSerpent = CouleurParComposante(255, 255, 0);
+  ChoisirCouleurDessin(couleurSerpent);
+
+  for (int i = 0; i < serpent.longueur; i++) {
+    RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE);
+  }
+}
+
+void GenererPommes() {
+  couleur couleurPommes = CouleurParComposante(255, 0, 0);
+  pommes.positions = malloc(sizeof(Position) * pommes.nombre);
+  
+  for (int i = 0; i < pommes.nombre; i++) {
+    pommes.positions[i].x = rand() % LARGEUR;
+    pommes.positions[i].y = rand() % HAUTEUR;
+    ChoisirCouleurDessin(couleurPommes);
+    RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
+  }
+}
+
+void GenererNouvellePomme() {
+  couleur couleurPommes = CouleurParComposante(255, 0, 0);
+  int i = rand() % pommes.nombre;  /* Utilisation d'une position aléatoire*/
+  pommes.positions[i].x = rand() % LARGEUR;
+  pommes.positions[i].y = rand() % HAUTEUR;
+  ChoisirCouleurDessin(couleurPommes);
+  RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
+}
+
+int CollisionAvecPomme() {
+  for (int i = 0; i < pommes.nombre; i++) {
+    /* Vérifier si la tête du serpent est à l'intérieur de la zone de la pomme*/
+    if (serpent.corps[0].x >= pommes.positions[i].x * TAILLE_CASE &&
+	serpent.corps[0].x < (pommes.positions[i].x + 1) * TAILLE_CASE &&
+	serpent.corps[0].y >= pommes.positions[i].y * TAILLE_CASE &&
+	serpent.corps[0].y < (pommes.positions[i].y + 1) * TAILLE_CASE) {
+      GenererNouvellePomme();  /* Générer une nouvelle position pour la pomme mangée*/
+      score= score +5;  /* Augmenter le score*/
+      AfficherScore();  /* Mettre à jour l'affichage du score*/
+      return 1;
+    }
+  }
+  return 0;
+}
+
+int CollisionAvecSerpent() {
+  for (int i = 1; i < serpent.longueur; i++) {
+    if (serpent.corps[0].x == serpent.corps[i].x && serpent.corps[0].y == serpent.corps[i].y) {
+      perdu = -1;  // Le serpent a perdu
+      return 1;
+    }
+  }
+  return 0;
+}
+
+int CollisionAvecBordures() {
+  if (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE ||
+      serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE) {
+    perdu = -1;  // Le serpent a perdu
+    return 1;
+  }
+  return 0;
+}
+
+void DeplacerSerpent(int* direction) {
+  couleur couleurFond = CouleurParComposante(0, 0, 0);
+  couleur couleurSerpent = CouleurParComposante(255, 255, 0);
+  couleur couleurTerrain = CouleurParComposante(111, 255, 94);
+  
+  for (int i = 0; i < serpent.longueur; i++) {
+    ChoisirCouleurDessin(couleurTerrain);
+    RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE);
+  }
+  
+  for (int i = serpent.longueur - 1; i > 0; i--) {
+    serpent.corps[i] = serpent.corps[i - 1];
+  }
+
+  if (ToucheEnAttente()) {
+    int touche = Touche();
+    switch (touche) {
+    case XK_Right:
+      *direction = 1;
+      break;
+    case XK_Left:
+      *direction = 2;
+      break;
+    case XK_Up:
+      *direction = 3;
+      break;
+    case XK_Down:
+      *direction = 4;
+      break;
+    }
+  }
+
+  if (*direction == 1) {
+    serpent.corps[0].x += TAILLE_CASE;
+  } else if (*direction == 2) {
+    serpent.corps[0].x -= TAILLE_CASE;
+  } else if (*direction == 3) {
+    serpent.corps[0].y -= TAILLE_CASE;
+  } else if (*direction == 4) {
+    serpent.corps[0].y += TAILLE_CASE;
+  }
+
+  for (int i = 0; i < serpent.longueur; i++) {
+    ChoisirCouleurDessin(couleurSerpent);
+    RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE);
+  }
+
+  Attendre(100);
+}
+
+int GestionCollision(int perdu) {
+  int loose = perdu;
+  if (CollisionAvecPomme()) {
+    serpent.longueur = serpent.longueur +2;
+    serpent.corps = realloc(serpent.corps, sizeof(Position) * serpent.longueur);
+    loose = 1;
+  }
+  if (CollisionAvecSerpent() || CollisionAvecBordures()) {
+    loose = -1;  /* Le serpent a perdu*/
+  }
+  /*printf("%d \n", loose);*/
+  return loose;
+}
+
+int main() {
+  int direction = 1;
+  unsigned long suivant = Microsecondes() + CYCLE;
+  int temps[2] = {0, 0}, seconde_actuel, old_seconde;
+  int jeuEnPause = 0;
+  int perdu = 0;
+
+  InitialiserJeu();
+  Graphique();
+  EffacerEcran(CouleurParComposante(0, 0, 0));
+  AffichageBasique();
+  GenererPommes();
+  AfficherSerpent();
+  AfficherScore();
+
+  while (perdu != -1) {
+    if (!jeuEnPause) {
+      if (Microsecondes() > suivant) {
+	suivant = Microsecondes() + CYCLE;
+	seconde_actuel = (suivant / 1000000) % 10;
+	if (seconde_actuel != old_seconde) {
+	  old_seconde = seconde_actuel;
+	  if ((temps[1] + 1) == 60) {
+	    temps[0]++;
+	    temps[1] = 0;
+	  } else {
+	    temps[1]++;
+	  }
+	  AfficheTemps(temps[0], temps[1]);
+	}
+      }
+      if (ToucheEnAttente()) {
+	int touche = Touche();
+	switch (touche) {
+	case XK_Right:
+	  direction = 1;
+	  break;
+	case XK_Left:
+	  direction = 2;
+	  break;
+	case XK_Up:
+	  direction = 3;
+	  break;
+	case XK_Down:
+	  direction = 4;
+	  break;
+	case XK_space:
+	  jeuEnPause = 1;
+	  break;
+	case XK_Escape:
+	  return EXIT_FAILURE;
+	}
+      }
+      DeplacerSerpent(&direction);
+      perdu = GestionCollision(perdu);
+      if (perdu == 1) {
+	GenererNouvellePomme();
+	perdu = 0;
+      }
+    } else {
+      /* Le jeu est en pause*/ 
+      if (ToucheEnAttente()) {
+	int touche = Touche();
+	if (touche == XK_space) {
+	  if(touche == XK_Escape){
+	    return EXIT_FAILURE;
+	  }
+	  jeuEnPause = 0;
+	} 
+      }
+    }
+  }
+
+  FermerGraphique();
+  LibererMemoire();
+  return EXIT_SUCCESS;
+}
diff --git a/.#serpent.c b/.#serpent.c
new file mode 120000
index 0000000..4a26999
--- /dev/null
+++ b/.#serpent.c
@@ -0,0 +1 @@
+rognant@salle235-14.17429:1702034892
\ No newline at end of file
diff --git a/serpent.c b/serpent.c
index 29484b9..18c0b12 100644
--- a/serpent.c
+++ b/serpent.c
@@ -27,187 +27,187 @@ typedef struct {
 
 Serpent serpent;
 Pommes pommes;
-int score = 0;  // Ajout de la variable score
 
-int perdu = 0;  // Variable pour indiquer si le serpent a perdu
+int score = 0;  
+int perdu = 0;
 
 void Attendre(unsigned int millisecondes) {
-    usleep(millisecondes * 1000);
+  usleep(millisecondes * 1000);
 }
 
 void InitialiserJeu() {
-    serpent.longueur = 10;
-    serpent.corps = malloc(sizeof(Position) * serpent.longueur);
-    pommes.nombre = NOMBRE_POMMES;
+  serpent.longueur = 10;
+  serpent.corps = malloc(sizeof(Position) * serpent.longueur);
+  pommes.nombre = NOMBRE_POMMES;
 
-    srand(time(NULL));
+  srand(time(NULL));
 
-    serpent.corps[0].x = LARGEUR / 2 * TAILLE_CASE;
-    serpent.corps[0].y = HAUTEUR / 2 * TAILLE_CASE;
-    perdu = 0;  // Initialisation de la variable perdu
+  serpent.corps[0].x = LARGEUR / 2 * TAILLE_CASE;
+  serpent.corps[0].y = HAUTEUR / 2 * TAILLE_CASE;
+  perdu = 0;  /* Initialisation de la variable perdu*/
 }
 
 void Graphique() {
-    InitialiserGraphique();
-    CreerFenetre(1, 1, 1240, 940);
-    EcrireTexte(500, 400, "Le jeu va commencer !", 2);
-    Attendre(1000);
-    EffacerEcran(CouleurParComposante(0, 0, 0));
+  InitialiserGraphique();
+  CreerFenetre(1, 1, 1240, 940);
+  EcrireTexte(500, 400, "Le jeu va commencer !", 2);
+  Attendre(1000);
+  EffacerEcran(CouleurParComposante(0, 0, 0));
 }
 
 void AffichageBasique() {
-    ChoisirCouleurDessin(CouleurParComposante(111, 255, 94));
-    RemplirRectangle(0, 0, 1175, 775);
+  ChoisirCouleurDessin(CouleurParComposante(111, 255, 94));
+  RemplirRectangle(0, 0, 1140, 760);
 }
 
 void AfficherScore() {
-    char scoreText[20];  // Correction de la taille du tableau
-    snprintf(scoreText, 20, "Score: %d", score);
-    ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
-    RemplirRectangle(20, 820, 150, 40);
-    ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
-    EcrireTexte(20, 850, scoreText, 2);
+  char scoreText[20];  /* Correction de la taille du tableau*/
+  snprintf(scoreText, 20, "Score: %d", score);
+  ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
+  RemplirRectangle(20, 820, 150, 40);
+  ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
+  EcrireTexte(20, 850, scoreText, 2);
 }
 
 int PauseJeu() {
-    while (1) {
-        if (ToucheEnAttente()) {
-            int touche = Touche();
-            if (touche == XK_space) {
-                return 1;  // La barre d'espace a été pressée, reprendre le jeu
-            }
-        }
-        Attendre(100);
+  while (1) {
+    if (ToucheEnAttente()) {
+      int touche = Touche();
+      if (touche == XK_space) {
+	return 1;  /* La barre d'espace a été pressée, reprendre le jeu*/
+      }
     }
+    Attendre(100);
+  }
 }
 
 void LibererMemoire() {
-    free(serpent.corps);
-    free(pommes.positions);
+  free(serpent.corps);
+  free(pommes.positions);
 }
 
 void AfficheTemps(int minute, int seconde) {
-    char temps[6];
-    snprintf(temps, 6, "%02d:%02d", minute, seconde);
-    ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
-    RemplirRectangle(20, 870, 70, 40);
-    ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
-    EcrireTexte(20, 900, temps, 2);
+  char temps[6];
+  snprintf(temps, 6, "%02d:%02d", minute, seconde);
+  ChoisirCouleurDessin(CouleurParComposante(0, 0, 0));
+  RemplirRectangle(20, 870, 70, 40);
+  ChoisirCouleurDessin(CouleurParComposante(255, 255, 255));
+  EcrireTexte(20, 900, temps, 2);
 }
 
 void AfficherSerpent() {
-    couleur couleurSerpent = CouleurParComposante(255, 255, 0);
-    ChoisirCouleurDessin(couleurSerpent);
+  couleur couleurSerpent = CouleurParComposante(255, 255, 0);
+  ChoisirCouleurDessin(couleurSerpent);
 
-    for (int i = 0; i < serpent.longueur; i++) {
-        RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE);
-    }
+  for (int i = 0; i < serpent.longueur; i++) {
+    RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE);
+  }
 }
 
 void GenererPommes() {
-    couleur couleurPommes = CouleurParComposante(255, 0, 0);
-    pommes.positions = malloc(sizeof(Position) * pommes.nombre);
-
-    for (int i = 0; i < pommes.nombre; i++) {
-        pommes.positions[i].x = rand() % LARGEUR;
-        pommes.positions[i].y = rand() % HAUTEUR;
-        ChoisirCouleurDessin(couleurPommes);
-        RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
-    }
-}
-
-void GenererNouvellePomme() {
-    couleur couleurPommes = CouleurParComposante(255, 0, 0);
-    int i = rand() % pommes.nombre;  // Utilisation d'une position aléatoire
+  couleur couleurPommes = CouleurParComposante(255, 0, 0);
+  pommes.positions = malloc(sizeof(Position) * pommes.nombre);
+  
+  for (int i = 0; i < pommes.nombre; i++) {
     pommes.positions[i].x = rand() % LARGEUR;
     pommes.positions[i].y = rand() % HAUTEUR;
     ChoisirCouleurDessin(couleurPommes);
     RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
+  }
+}
+
+void GenererNouvellePomme() {
+  couleur couleurPommes = CouleurParComposante(255, 0, 0);
+  int i = rand() % pommes.nombre;  /* Utilisation d'une position aléatoire*/
+  pommes.positions[i].x = rand() % LARGEUR;
+  pommes.positions[i].y = rand() % HAUTEUR;
+  ChoisirCouleurDessin(couleurPommes);
+  RemplirRectangle(pommes.positions[i].x * TAILLE_CASE, pommes.positions[i].y * TAILLE_CASE, TAILLE_CASE, TAILLE_CASE);
 }
 
 int CollisionAvecPomme() {
-    for (int i = 0; i < pommes.nombre; i++) {
-        /* Vérifier si la tête du serpent est à l'intérieur de la zone de la pomme*/
-        if (serpent.corps[0].x >= pommes.positions[i].x * TAILLE_CASE &&
-            serpent.corps[0].x < (pommes.positions[i].x + 1) * TAILLE_CASE &&
-            serpent.corps[0].y >= pommes.positions[i].y * TAILLE_CASE &&
-            serpent.corps[0].y < (pommes.positions[i].y + 1) * TAILLE_CASE) {
-            GenererNouvellePomme();  // Générer une nouvelle position pour la pomme mangée
-            score= score +5;  // Augmenter le score
-            AfficherScore();  // Mettre à jour l'affichage du score
-            return 1;
-        }
+  for (int i = 0; i < pommes.nombre; i++) {
+    /* Vérifier si la tête du serpent est à l'intérieur de la zone de la pomme*/
+    if (serpent.corps[0].x >= pommes.positions[i].x * TAILLE_CASE &&
+	serpent.corps[0].x < (pommes.positions[i].x + 1) * TAILLE_CASE &&
+	serpent.corps[0].y >= pommes.positions[i].y * TAILLE_CASE &&
+	serpent.corps[0].y < (pommes.positions[i].y + 1) * TAILLE_CASE) {
+      GenererNouvellePomme();  /* Générer une nouvelle position pour la pomme mangée*/
+      score= score +5;  /* Augmenter le score*/
+      AfficherScore();  /* Mettre à jour l'affichage du score*/
+      return 1;
     }
-    return 0;
+  }
+  return 0;
 }
 
 int CollisionAvecSerpent() {
-    for (int i = 1; i < serpent.longueur; i++) {
-        if (serpent.corps[0].x == serpent.corps[i].x && serpent.corps[0].y == serpent.corps[i].y) {
-            perdu = -1;  // Le serpent a perdu
-            return 1;
-        }
+  for (int i = 1; i < serpent.longueur; i++) {
+    if (serpent.corps[0].x == serpent.corps[i].x && serpent.corps[0].y == serpent.corps[i].y) {
+      perdu = -1;  // Le serpent a perdu
+      return 1;
     }
-    return 0;
+  }
+  return 0;
 }
 
 int CollisionAvecBordures() {
-    if (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE ||
-        serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE) {
-        perdu = -1;  // Le serpent a perdu
-        return 1;
-    }
-    return 0;
+  if (serpent.corps[0].x < 0 || serpent.corps[0].x >= LARGEUR * TAILLE_CASE ||
+      serpent.corps[0].y < 0 || serpent.corps[0].y >= HAUTEUR * TAILLE_CASE) {
+    perdu = -1;  // Le serpent a perdu
+    return 1;
+  }
+  return 0;
 }
 
 void DeplacerSerpent(int* direction) {
-    couleur couleurFond = CouleurParComposante(0, 0, 0);
-    couleur couleurSerpent = CouleurParComposante(255, 255, 0);
-    couleur couleurTerrain = CouleurParComposante(111, 255, 94);
+  couleur couleurFond = CouleurParComposante(0, 0, 0);
+  couleur couleurSerpent = CouleurParComposante(255, 255, 0);
+  couleur couleurTerrain = CouleurParComposante(111, 255, 94);
+  
+  for (int i = 0; i < serpent.longueur; i++) {
+    ChoisirCouleurDessin(couleurTerrain);
+    RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE);
+  }
+  
+  for (int i = serpent.longueur - 1; i > 0; i--) {
+    serpent.corps[i] = serpent.corps[i - 1];
+  }
 
-    for (int i = 0; i < serpent.longueur; i++) {
-        ChoisirCouleurDessin(couleurTerrain);
-        RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE);
+  if (ToucheEnAttente()) {
+    int touche = Touche();
+    switch (touche) {
+    case XK_Right:
+      *direction = 1;
+      break;
+    case XK_Left:
+      *direction = 2;
+      break;
+    case XK_Up:
+      *direction = 3;
+      break;
+    case XK_Down:
+      *direction = 4;
+      break;
     }
+  }
 
-    for (int i = serpent.longueur - 1; i > 0; i--) {
-        serpent.corps[i] = serpent.corps[i - 1];
-    }
+  if (*direction == 1) {
+    serpent.corps[0].x += TAILLE_CASE;
+  } else if (*direction == 2) {
+    serpent.corps[0].x -= TAILLE_CASE;
+  } else if (*direction == 3) {
+    serpent.corps[0].y -= TAILLE_CASE;
+  } else if (*direction == 4) {
+    serpent.corps[0].y += TAILLE_CASE;
+  }
 
-    if (ToucheEnAttente()) {
-        int touche = Touche();
-        switch (touche) {
-            case XK_Right:
-                *direction = 1;
-                break;
-            case XK_Left:
-                *direction = 2;
-                break;
-            case XK_Up:
-                *direction = 3;
-                break;
-            case XK_Down:
-                *direction = 4;
-                break;
-        }
-    }
+  for (int i = 0; i < serpent.longueur; i++) {
+    ChoisirCouleurDessin(couleurSerpent);
+    RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE);
+  }
 
-    if (*direction == 1) {
-        serpent.corps[0].x += TAILLE_CASE;
-    } else if (*direction == 2) {
-        serpent.corps[0].x -= TAILLE_CASE;
-    } else if (*direction == 3) {
-        serpent.corps[0].y -= TAILLE_CASE;
-    } else if (*direction == 4) {
-        serpent.corps[0].y += TAILLE_CASE;
-    }
-
-    for (int i = 0; i < serpent.longueur; i++) {
-        ChoisirCouleurDessin(couleurSerpent);
-        RemplirRectangle(serpent.corps[i].x, serpent.corps[i].y, TAILLE_CASE, TAILLE_CASE);
-    }
-
-    Attendre(100);
+  Attendre(100);
 }
 
 int GestionCollision(int perdu) {
@@ -220,79 +220,84 @@ int GestionCollision(int perdu) {
   if (CollisionAvecSerpent() || CollisionAvecBordures()) {
     loose = -1;  /* Le serpent a perdu*/
   }
-  printf("%d \n", loose);
+  /*printf("%d \n", loose);*/
   return loose;
 }
 
 int main() {
-    int direction = 1;
-    unsigned long suivant = Microsecondes() + CYCLE;
-    int temps[2] = {0, 0}, seconde_actuel, old_seconde;
-    int jeuEnPause = 0;
-    int perdu = 0;
+  int direction = 1;
+  unsigned long suivant = Microsecondes() + CYCLE;
+  int temps[2] = {0, 0}, seconde_actuel, old_seconde;
+  int jeuEnPause = 0;
+  int perdu = 0;
 
-    InitialiserJeu();
-    Graphique();
-    EffacerEcran(CouleurParComposante(0, 0, 0));
-    AffichageBasique();
-    GenererPommes();
-    AfficherSerpent();
-    AfficherScore();
+  InitialiserJeu();
+  Graphique();
+  EffacerEcran(CouleurParComposante(0, 0, 0));
+  AffichageBasique();
+  GenererPommes();
+  AfficherSerpent();
+  AfficherScore();
 
-    while (perdu != -1) {
-        if (!jeuEnPause) {
-            if (Microsecondes() > suivant) {
-                suivant = Microsecondes() + CYCLE;
-                seconde_actuel = (suivant / 1000000) % 10;
-                if (seconde_actuel != old_seconde) {
-                    old_seconde = seconde_actuel;
-                    if ((temps[1] + 1) == 60) {
-                        temps[0]++;
-                        temps[1] = 0;
-                    } else {
-                        temps[1]++;
-                    }
-                    AfficheTemps(temps[0], temps[1]);
-                }
-            }
-            if (ToucheEnAttente()) {
-                int touche = Touche();
-                switch (touche) {
-                    case XK_Right:
-                        direction = 1;
-                        break;
-                    case XK_Left:
-                        direction = 2;
-                        break;
-                    case XK_Up:
-                        direction = 3;
-                        break;
-                    case XK_Down:
-                        direction = 4;
-                        break;
-                    case XK_space:
-                        jeuEnPause = 1;
-                        break;
-                }
-            }
-            DeplacerSerpent(&direction);
-            perdu = GestionCollision(perdu);
-            if (perdu == 1) {
-	      GenererNouvellePomme();
-	      perdu = 0;
-            }
-        } else {
-            // Le jeu est en pause
-            if (ToucheEnAttente()) {
-                int touche = Touche();
-                if (touche == XK_space) {
-                    jeuEnPause = 0;
-                }
-            }
-        }
+  while (perdu != -1) {
+    if (!jeuEnPause) {
+      if (Microsecondes() > suivant) {
+	suivant = Microsecondes() + CYCLE;
+	seconde_actuel = (suivant / 1000000) % 10;
+	if (seconde_actuel != old_seconde) {
+	  old_seconde = seconde_actuel;
+	  if ((temps[1] + 1) == 60) {
+	    temps[0]++;
+	    temps[1] = 0;
+	  } else {
+	    temps[1]++;
+	  }
+	  AfficheTemps(temps[0], temps[1]);
+	}
+      }
+      if (ToucheEnAttente()) {
+	int touche = Touche();
+	switch (touche) {
+	case XK_Right:
+	  direction = 1;
+	  break;
+	case XK_Left:
+	  direction = 2;
+	  break;
+	case XK_Up:
+	  direction = 3;
+	  break;
+	case XK_Down:
+	  direction = 4;
+	  break;
+	case XK_space:
+	  jeuEnPause = 1;
+	  break;
+	case XK_Escape:
+	  return EXIT_FAILURE;
+	}
+      }
+      DeplacerSerpent(&direction);
+      perdu = GestionCollision(perdu);
+      if (perdu == 1) {
+	GenererNouvellePomme();
+	perdu = 0;
+      }
+    } else {
+      /* Le jeu est en pause*/
+      if (ToucheEnAttente()) {
+	int touche = Touche();
+	if (touche == XK_space) {
+	  if(touche == XK_Escape){
+	    return EXIT_FAILURE;
+	  }
+	  jeuEnPause = 0;
+	}
+      }
     }
+  }
 
-    FermerGraphique();
-    LibererMemoire();
-    return EXIT_SUCCESS;
+  FermerGraphique();
+  LibererMemoire();
+  return EXIT_SUCCESS;
 }