diff --git a/Interactif/Interactif.c b/Interactif/Interactif.c
index 5465d8b..ac62181 100644
--- a/Interactif/Interactif.c
+++ b/Interactif/Interactif.c
@@ -12,34 +12,34 @@
 #define ErreurHitbox 2
 
 
-int CheckCollisionEntiteEntite(struct entite enti1, int L1, int H1, struct entite enti2, int L2, int H2)
+int CheckCollisionEntiteEntite(struct entite entite1, int L1, int H1, struct entite entite2, int L2, int H2)
 {
     //CheckX
-    int gauche1 = enti1.posx - L1/2 + ErreurHitbox;
-    int droite1 = enti1.posx + L1/2 - ErreurHitbox;
-    int gauche2 = enti2.posx - L2/2 + ErreurHitbox;
-    int droite2 = enti2.posx + L2/2 - ErreurHitbox;
+    int gauche1 = entite1.posx - L1/2 + ErreurHitbox;
+    int droite1 = entite1.posx + L1/2 - ErreurHitbox;
+    int gauche2 = entite2.posx - L2/2 + ErreurHitbox;
+    int droite2 = entite2.posx + L2/2 - ErreurHitbox;
     int CheckX = (gauche1 >= gauche2 && gauche1 <= droite2) || (droite1 >= gauche2 && droite1 <= droite2);
 
     //CheckY
-    int haut1 = enti1.posy - H1/2 + ErreurHitbox;
-    int bas1  = enti1.posy + H1/2 - ErreurHitbox;
-    int haut2 = enti2.posy - H2/2 + ErreurHitbox;
-    int bas2  = enti2.posy + H2/2 - ErreurHitbox;
+    int haut1 = entite1.posy - H1/2 + ErreurHitbox;
+    int bas1  = entite1.posy + H1/2 - ErreurHitbox;
+    int haut2 = entite2.posy - H2/2 + ErreurHitbox;
+    int bas2  = entite2.posy + H2/2 - ErreurHitbox;
     int CheckY = (haut1 <= bas2 && haut1 >= haut2) || (bas1 <= bas2 && bas1 >= haut2);
 
     return CheckX && CheckY;
 }
 
 
-struct entite* CheckCollisionListeEntite(struct liste_entite *Liste1,int L1,int H1,struct entite enti2, int L2, int H2)
+struct entite* CheckCollisionListeEntite(struct liste_entite *Liste1,int L1,int H1,struct entite entite2, int L2, int H2)
 {
     struct liste_entite *pL1=Liste1;
     while (pL1 != NULL)
     {
-        if(CheckCollisionEntiteEntite(pL1->enti,L1,H1,enti2,L2,H2) == 1)
+        if(CheckCollisionEntiteEntite(pL1->entite,L1,H1,entite2,L2,H2) == 1)
         {
-            return &pL1->enti;
+            return &pL1->entite;
         }
         pL1=pL1->suivant;
     }
@@ -54,22 +54,22 @@ struct liste_entite* CheckCollisionListeListe(struct liste_entite *Liste1,int L1
     struct liste_entite *pL2=Liste2;
     while (pL2 != NULL)
     {
-        struct entite* collision = CheckCollisionListeEntite(Liste1,L1,H1,pL2->enti,L2,H2);
+        struct entite* collision = CheckCollisionListeEntite(Liste1,L1,H1,pL2->entite,L2,H2);
         if (collision != NULL)
         {
             // Création des nœuds pour les deux entités
-            struct liste_entite* Enti1 = malloc(sizeof(struct liste_entite));
-            struct liste_entite* Enti2 = malloc(sizeof(struct liste_entite));
+            struct liste_entite* Entite1 = malloc(sizeof(struct liste_entite));
+            struct liste_entite* Entite2 = malloc(sizeof(struct liste_entite));
 
             // Remplissage des nœuds avec les entités correspondantes
-            Enti1->enti = *collision;
-            Enti2->enti = pL2->enti;
+            Entite1->entite = *collision;
+            Entite2->entite = pL2->entite;
 
             // Relier les nœuds entre eux
-            Enti1->suivant = Enti2;
-            Enti2->suivant = NULL;
+            Entite1->suivant = Entite2;
+            Entite2->suivant = NULL;
 
-            return Enti1;
+            return Entite1;
         }
         else
             pL2=pL2->suivant;
@@ -86,16 +86,16 @@ int SupprimerEntitesEnCollision(struct liste_entite** Liste1, int L1, int H1, st
     
     if (collision != NULL) {
         // Récupération des entités impliquées
-        struct entite* enti1 = &collision->enti;
-        struct entite* enti2 = &collision->suivant->enti;
+        struct entite* entite1 = &collision->entite;
+        struct entite* entite2 = &collision->suivant->entite;
         
         // Suppression de l'entité 1 de la liste 1
-        SupprimerEntite(Liste1, enti1);
+        SupprimerEntite(Liste1, entite1);
         
         // Suppression de l'entité 2 de la liste 2
-        SupprimerEntite(Liste2, enti2);
+        SupprimerEntite(Liste2, entite2);
         
-       afficherLutin(bouillie, enti2->posx - hitboxbouillieL/2 + ErreurHitbox, enti2->posy - hitboxbouillieH/2 + ErreurHitbox);
+       afficherLutin(bouillie, entite2->posx - hitboxbouillieL/2 + ErreurHitbox, entite2->posy - hitboxbouillieH/2 + ErreurHitbox);
        
        return 1;
     }
@@ -117,7 +117,7 @@ void Tirer(struct entite joueur, struct liste_entite **pl)
     
 void DeplacementTire(int tire, struct liste_entite** l)
 {
-    struct entite* ml = &(*l)->enti;
+    struct entite* ml = &(*l)->entite;
     if (ml != NULL) 
     {
         if (ml->posy <= 0) 
@@ -180,9 +180,9 @@ void MakeBombeDroppable(struct liste_entite* enemies, struct liste_entite** bomb
     int taille = 0;
     while (pL != NULL)
     {
-        if (pL->enti.dropbombe == 1)
+        if (pL->entite.dropbombe == 1)
         {
-            ajout_tete(&Dropable,pL->enti);
+            ajout_tete(&Dropable,pL->entite);
             taille += 1;
         }
         pL=pL->suivant;
@@ -200,7 +200,7 @@ void MakeBombeDroppable(struct liste_entite* enemies, struct liste_entite** bomb
     {
         pLDropable = pLDropable->suivant;
     }    
-    ajout_tete(bombes,creer_entite(pLDropable->enti.posx,pLDropable->enti.posy,-1));
+    ajout_tete(bombes,creer_entite(pLDropable->entite.posx,pLDropable->entite.posy,-1));
 }
 
 
@@ -211,16 +211,16 @@ void DeplacementBombe(int bombe, struct liste_entite** l)
     
     while (ml != NULL) 
     {
-        if (ml->enti.posy + hitboxbombeH/2 - ErreurHitbox >= Sol) 
+        if (ml->entite.posy + hitboxbombeH/2 - ErreurHitbox >= Sol) 
         {
-            struct entite* a_supprimer = &ml->enti;
+            struct entite* a_supprimer = &ml->entite;
             ml = ml->suivant;
             SupprimerEntite(l, a_supprimer);
         } 
         else 
         {
-            ml->enti.posy += 2;
-            afficherLutin(bombe, ml->enti.posx - hitboxbombeL/2 + ErreurHitbox, ml->enti.posy - hitboxbombeH/2 + ErreurHitbox);
+            ml->entite.posy += 2;
+            afficherLutin(bombe, ml->entite.posx - hitboxbombeL/2 + ErreurHitbox, ml->entite.posy - hitboxbombeH/2 + ErreurHitbox);
             precedent = ml;
             ml = ml->suivant;
         }
diff --git a/ListeC/Liste.c b/ListeC/Liste.c
index f76f437..07bc0cb 100644
--- a/ListeC/Liste.c
+++ b/ListeC/Liste.c
@@ -1,64 +1,69 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "Liste.h"
 
 
-struct entite creer_entite(int x, int y, int bombe)
+struct entite creer_entite (int x, 
+                            int y, 
+                            int bombe)
 {
     struct entite e;
-    e.posx = x;
-    e.posy = y;
+    
+    e.posx      = x;
+    e.posy      = y;
     e.dropbombe = bombe;
+    
     return e;
 }
 
-void ajout_tete(struct liste_entite **pL, struct entite x)
-{
-    struct liste_entite *tmp;
-    tmp = malloc(sizeof(struct liste_entite));
-    tmp->enti = x;
-    tmp->suivant = *pL;
-    *pL = tmp;
-}
 
 
-void imprimer_liste(struct liste_entite *l)
+void ajout_tete (struct liste_entite** Liste,
+                 struct entite         x    )
 {
-    struct liste_entite *p;
-    p = l;
-    while (p != NULL)
-    {
-        printf("%d -> ",p->enti.posx);
-        p=p->suivant;
-    }
-    printf("\n");
+    struct liste_entite *Listetmp;
+    
+    Listetmp            = malloc(sizeof(struct liste_entite));
+    Listetmp->entite    = x;
+    Listetmp->suivant   = *Liste;
+    
+    *Liste              = Listetmp;
 }
 
 
 
-void SupprimerEntite(struct liste_entite** Liste, struct entite* enti) 
+void SupprimerEntite (struct liste_entite** Liste,
+                      struct entite*        entite) 
 {
-    struct liste_entite* courant = *Liste;
+    struct liste_entite* courant   = *Liste;
     struct liste_entite* precedent = NULL;
     
     while (courant != NULL) 
     {
-        if (memcmp(&courant->enti, enti, sizeof(struct entite)) == 0) 
+        
+        if (memcmp (&courant->entite,
+                    entite,
+                    sizeof(struct entite)) == 0) 
         {
+            
             if (precedent == NULL) 
             {
                 *Liste = courant->suivant;
             } 
+            
             else 
             {
                 precedent->suivant = courant->suivant;
             }
+            
             free(courant);
             break;
         }
+        
         precedent = courant;
-        courant = courant->suivant;
+        courant   = courant->suivant;
     }
 }
 
diff --git a/ListeC/Liste.h b/ListeC/Liste.h
index 15602c9..d48387f 100644
--- a/ListeC/Liste.h
+++ b/ListeC/Liste.h
@@ -14,7 +14,7 @@ struct entite
     
 struct liste_entite
 {
-    struct entite enti;
+    struct entite entite;
     struct liste_entite *suivant;
 };
   
@@ -23,7 +23,5 @@ void ajout_tete(struct liste_entite**, struct entite);
 
 struct entite creer_entite(int,int,int);
 
-void imprimer_liste(struct liste_entite*);
-
 void SupprimerEntite(struct liste_entite**,struct entite*);
 
diff --git a/Main/init.c b/Main/init.c
index 02b950c..798a468 100644
--- a/Main/init.c
+++ b/Main/init.c
@@ -1,5 +1,6 @@
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "../Graphique/libgraph.h"
 #include "../ListeC/Liste.h"
 #include "../Interactif/Interactif.h"
@@ -14,80 +15,113 @@
     
 struct entite joueur;
 
-int canon=0;
-int missile=0;
-int sbire=0;
-int bouillie=0;
-int bombe=0;
-
-char Nom[15]="Space Invader";
-char input='\0';
+int  canon           = 0;
+int  missile         = 0;
+int  sbire           = 0;
+int  bouillie        = 0;
+int  bombe           = 0;
 
-int hitboxcanonL=0;
-int hitboxcanonH=0;
-int hitboxmissileL=0;
-int hitboxmissileH=0;
-int hitboxsbireL=0;
-int hitboxsbireH=0;
-int hitboxbouillieL=0;
-int hitboxbouillieH=0;
-int hitboxbombeL=0;
-int hitboxbombeH=0;
+int  hitboxcanonL    = 0;
+int  hitboxcanonH    = 0;
+int  hitboxmissileL  = 0;
+int  hitboxmissileH  = 0;
+int  hitboxsbireL    = 0;
+int  hitboxsbireH    = 0;
+int  hitboxbouillieL = 0;
+int  hitboxbouillieH = 0;
+int  hitboxbombeL    = 0;
+int  hitboxbombeH    = 0;
 
+char Nom[]           = "Space Invader";
+char input           = '\0';
 
 
 void initialiser()
 {
-    canon = chargerLutin("../../Lutins/invader_canon.bmp",COULEUR_NOIR);
-    missile = chargerLutin("../../Lutins/invader_missile.bmp",COULEUR_NOIR);
-    sbire = chargerLutin("../../Lutins/invader_monstre1_1.bmp",COULEUR_NOIR);
-    bouillie = chargerLutin("../../Lutins/invader_monstre_bouillie.bmp",COULEUR_NOIR);
-    bombe = chargerLutin("../../Lutins/invader_bombe.bmp",COULEUR_NOIR);
-    
-    tailleLutin(canon,&hitboxcanonL,&hitboxcanonH);
-    tailleLutin(missile,&hitboxmissileL,&hitboxmissileH);
-    tailleLutin(sbire,&hitboxsbireL,&hitboxsbireH);
-    tailleLutin(bouillie,&hitboxbouillieL,&hitboxbouillieH);
-    tailleLutin(bombe,&hitboxbombeL,&hitboxbombeH);
+    canon    = chargerLutin ("../../Lutins/invader_canon.bmp",
+                             COULEUR_NOIR);
+    missile  = chargerLutin ("../../Lutins/invader_missile.bmp",
+                             COULEUR_NOIR);
+    sbire    = chargerLutin ("../../Lutins/invader_monstre1_1.bmp",
+                             COULEUR_NOIR);
+    bouillie = chargerLutin ("../../Lutins/invader_monstre_bouillie.bmp",
+                             COULEUR_NOIR);
+    bombe    = chargerLutin ("../../Lutins/invader_bombe.bmp",
+                             COULEUR_NOIR);
+    
+    tailleLutin (canon,
+                 &hitboxcanonL,
+                 &hitboxcanonH);
+    tailleLutin (missile,
+                 &hitboxmissileL,
+                 &hitboxmissileH);
+    tailleLutin (sbire,
+                 &hitboxsbireL,
+                 &hitboxsbireH);
+    tailleLutin (bouillie,
+                 &hitboxbouillieL,
+                 &hitboxbouillieH);
+    tailleLutin (bombe,
+                 &hitboxbombeL,
+                 &hitboxbombeH);
 
 }
 
+
 void initialiserjoueur(struct entite* joueur)
 {
-    joueur->posx = JoueurX;
-    joueur->posy = JoueurY;
+    joueur->posx      = JoueurX;
+    joueur->posy      = JoueurY;
     joueur->dropbombe = -1;
 }
 
 
-
 char pagedemarrage()
 {
-    static const char policeDefaut[]="/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";
-    int Largeur, Hauteur;
-    
-    rectanglePlein(0,0,TailleX,TailleY,COULEUR_NOIR);
-    char jouer[26]="Appuyer sur j pour Jouer";
-    char quitter[30]="Appuyer ailleurs pour Quitter";
-    
-    choisirPolice(policeDefaut,50);
-    int Bienvenue = lutinTexte(Nom,COULEUR_VERT);
-    tailleLutin(Bienvenue,&Largeur,&Hauteur);
-    afficherLutin(Bienvenue,TailleX/2-Largeur/2,TailleY/4+Hauteur/2);
-    
-    choisirPolice(policeDefaut,20);
-    
-    int J = lutinTexte(jouer,COULEUR_BLANC);
-    tailleLutin(J,&Largeur,&Hauteur);
-    afficherLutin(J,TailleX/2-Largeur/2,TailleY/2-Hauteur/2);
-    
-    int Q = lutinTexte(quitter,COULEUR_BLANC);
-    tailleLutin(Q,&Largeur,&Hauteur);
-    afficherLutin(Q,TailleX/2-Largeur/2,TailleY/2+Hauteur/2);
+    static const char policeDefaut[] = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";
+    int  Largeur        = 0;
+    int  Hauteur        = 0;
+    char jouer[]        = "Appuyer sur j pour Jouer";
+    char quitter[]      = "Appuyer ailleurs pour Quitter";
+    
+    choisirPolice (policeDefaut, TailleX / 20);
+    int  LutinJouer     = lutinTexte (jouer, COULEUR_BLANC);
+    int  LutinQuitter   = lutinTexte (quitter, COULEUR_BLANC);
+    
+    choisirPolice (policeDefaut,TailleX / 10);
+    int  LutinBienvenue = lutinTexte (Nom, COULEUR_VERT);
+    
+    rectanglePlein (0,
+                    0,
+                    TailleX,
+                    TailleY,
+                    COULEUR_NOIR);
+     
+    tailleLutin   (LutinBienvenue,
+                   &Largeur,
+                   &Hauteur);
+    afficherLutin (LutinBienvenue,
+                   TailleX / 2 - Largeur / 2,
+                   TailleY / 4 + Hauteur / 2);
+    
+    tailleLutin   (LutinJouer,
+                   &Largeur,
+                   &Hauteur);
+    afficherLutin (LutinJouer,
+                   TailleX/2-Largeur/2,
+                   TailleY/2-Hauteur/2);
+    
+    tailleLutin   (LutinQuitter,
+                   &Largeur,
+                   &Hauteur);
+    afficherLutin (LutinQuitter,
+                   TailleX / 2 - Largeur / 2,
+                   TailleY / 2 + Hauteur / 2);
    
     attendreEvenement ();
+    
     input = touche();
-    while (input=='\0')
+    while (input == '\0')
     {
         input = touche();
     }
@@ -95,44 +129,64 @@ char pagedemarrage()
 }
 
 
-void pagemort(int vie)
+void pagemort (int nbr_vie)
 {
-    static const char policeDefaut[]="/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";
-    int Largeur, Hauteur;
-    
-    rectanglePlein(0,0,TailleX,TailleY,COULEUR_NOIR);
-    char mort[16]="Vous etes mort";
-    char nbr_vie[30];
-    sprintf(nbr_vie, "Nombre de vie restante : %d", vie);
-
-    
-    choisirPolice(policeDefaut,40);
-    
-    int M = lutinTexte(mort,COULEUR_ROUGE);
-    tailleLutin(M,&Largeur,&Hauteur);
-    afficherLutin(M,TailleX/2-Largeur/2,TailleY/4+Hauteur/2);
-    
-    choisirPolice(policeDefaut,20);
-    
-    int V = lutinTexte(nbr_vie,COULEUR_BLANC);
-    tailleLutin(V,&Largeur,&Hauteur);
-    afficherLutin(V,TailleX/2-Largeur/2,TailleY/2-Hauteur/2);
+    static const char policeDefaut[] = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";
+    int Largeur    = 0;
+    int Hauteur    = 0;
+    char mort[]    = "Vous etes mort";
+    char vie[30]   = "\0";
+    sprintf(vie, "Nombre de vie restante : %d", nbr_vie);
+    
+    choisirPolice (policeDefaut, TailleX / 10);
+    int LutinMort  = lutinTexte(mort, COULEUR_ROUGE);
+    
+    choisirPolice (policeDefaut, TailleX / 20);
+    int LutinVie   = lutinTexte(vie, COULEUR_BLANC);
+    
+    rectanglePlein (0,
+                    0,
+                    TailleX,
+                    TailleY,
+                    COULEUR_NOIR);
+
+    tailleLutin   (LutinMort,
+                   &Largeur,
+                   &Hauteur);
+    afficherLutin (LutinMort,
+                   TailleX / 2 - Largeur / 2,
+                   TailleY / 4 + Hauteur / 2);
+    
+    tailleLutin   (LutinVie,
+                   &Largeur,
+                   &Hauteur);
+    afficherLutin (LutinVie,
+                   TailleX / 2 - Largeur / 2,
+                   TailleY / 2 - Hauteur / 2);
 }
 
 
 void pageGameOver()
 {
-    static const char policeDefaut[]="/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";
-    int Largeur, Hauteur;
-    
-    rectanglePlein(0,0,TailleX,TailleY,COULEUR_NOIR);
-    char fin[11]="GAME OVER";
-    
-    choisirPolice(policeDefaut,40);
-    
-    int F = lutinTexte(fin,COULEUR_ROUGE);
-    tailleLutin(F,&Largeur,&Hauteur);
-    afficherLutin(F,TailleX/2-Largeur/2,TailleY/2);
+    static const char policeDefaut[] = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf";
+    int Largeur  = 0;
+    int Hauteur  = 0;
+    char fin[]   = "GAME OVER";
+    
+    choisirPolice(policeDefaut, TailleX / 10);
+    int LutinFin = lutinTexte(fin, COULEUR_ROUGE);
+    
+    rectanglePlein (0,
+                    0,
+                    TailleX,
+                    TailleY,
+                    COULEUR_NOIR);
+    
+    tailleLutin   (LutinFin,
+                   &Largeur,
+                   &Hauteur);
+    afficherLutin (LutinFin,
+                   TailleX / 2 - Largeur / 2,
+                   TailleY / 2 - Hauteur / 2);
     
 }
-    
diff --git a/Main/main.c b/Main/main.c
index 173261e..e176a84 100644
--- a/Main/main.c
+++ b/Main/main.c
@@ -51,7 +51,6 @@ int main()
             if (nbr_vie > 0)
             {
                 pagemort(nbr_vie);
-                printf("%d \n",joueur.posx);
                 majSurface();
                 SDL_Delay(2000);
                 mort = 0;
@@ -71,8 +70,8 @@ int main()
         rectanglePlein(0,0,TailleX,TailleY,COULEUR_NOIR);
         rectanglePlein(0,Sol,TailleX,2,COULEUR_VERT);
 
-        afficherLutin(canon,Ljoueur->enti.posx - hitboxcanonL/2 + ErreurHitbox,Ljoueur->enti.posy);
-        AfficherSbire(sbire,hitboxsbireL,hitboxsbireH,enemies);
+        afficherLutin(canon,Ljoueur->entite.posx - hitboxcanonL/2 + ErreurHitbox,Ljoueur->entite.posy);
+        AfficherSbire(enemies,sbire,hitboxsbireL,hitboxsbireH);
            
         if (DropAlea == 0)
         {
@@ -86,7 +85,7 @@ int main()
         }
         
         input = touche();
-        action(&Ljoueur->enti,input,&tires);
+        action(&Ljoueur->entite,input,&tires);
 
         if (compteur==10)
         {
diff --git a/Monstre/Monstre.c b/Monstre/Monstre.c
index 0335b81..fadf4fd 100644
--- a/Monstre/Monstre.c
+++ b/Monstre/Monstre.c
@@ -1,5 +1,6 @@
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "../Graphique/libgraph.h"
 #include "../ListeC/Liste.h"
 #include "Monstre.h"
@@ -9,82 +10,90 @@
 #define ErreurHitbox 2
 
 //Sens = 1 -> Va vers la droite
-void DeplacementSbire(struct liste_entite *l, int *psens, int speed)
+void DeplacementSbire(struct liste_entite* Liste,
+                      int*                 SensDeplacement,
+                      int                  Vitesse)
 {
-    int ind=0;
-    struct liste_entite *ml=l;
-    while(ml != NULL)
-    {
-        if (*psens==1)
-        {
-            ml->enti.posx+=speed;
-            if(ml->enti.posx>=9*TailleX/10)ind=1;
-        }
-        else
-        {
-            ml->enti.posx-=speed;
-            if(ml->enti.posx<=TailleX/10)ind=2;
-        }
-        ml=ml->suivant;
-    }
-    if (ind==1)
+    
+    int                  ind    = 0;
+    struct liste_entite* pListe = Liste;
+
+    while (pListe != NULL)
     {
-        *psens=0;
-        struct liste_entite *ml2=l;
-        while(ml2 != NULL)
-        {
-            ml2->enti.posy+=30;
-            ml2=ml2->suivant;
-        }
+        pListe->entite.posx += (*SensDeplacement == 1) ? Vitesse : -Vitesse;
+
+        if      (pListe->entite.posx >= 9 * TailleX / 10)  
+                ind = 1;
+        
+        else if (pListe->entite.posx <= TailleX / 10) 
+                 ind = 2;
+
+        pListe = pListe->suivant;
     }
-    else if (ind==2)
+
+    if (ind != 0)
     {
-        *psens=1;
-        struct liste_entite *ml2=l;
-        while(ml2 != NULL)
+        *SensDeplacement             = (ind == 1) ? 0 : 1;
+        struct liste_entite* p2Liste = Liste;
+        
+        while (p2Liste != NULL)
         {
-            ml2->enti.posy+=30;
-            ml2=ml2->suivant;
+            p2Liste->entite.posy += 30;
+            p2Liste               = p2Liste->suivant;
         }
     }
 }
 
 
-
-void LigneSbire(struct liste_entite **enemies,int nbr_enemies, int nbr_rangee)
+void LigneSbire (struct liste_entite** ListeSbire,
+                 int                   nbr_enemies, 
+                 int                   nbr_rangee)
 {
-    for (int j=1; j<= nbr_rangee; j++)
+    
+    for (int j = 1; j <= nbr_rangee; j++)
     {
-        int compteurY=j*TailleY/10;
-        int compteurX=TailleX/nbr_enemies;
+        int compteurY = j * TailleY / 10;
+        int compteurX = TailleX / nbr_enemies;
         
-        for (int i=0; i<nbr_enemies; i++)
+        for (int i = 0; i < nbr_enemies; i++)
         {
             if (j == nbr_rangee)
             {
-                ajout_tete(enemies,creer_entite(compteurX,compteurY,1));
-                compteurX +=2*TailleX/(3*nbr_enemies);
+                ajout_tete(ListeSbire,
+                           creer_entite(compteurX,
+                                        compteurY,
+                                        1)
+                          );
+                compteurX += 2 * TailleX / (3 * nbr_enemies);
             }
+            
             else
             {
-                ajout_tete(enemies,creer_entite(compteurX,compteurY,0));
-                compteurX +=2*TailleX/(3*nbr_enemies);
+                ajout_tete(ListeSbire,
+                           creer_entite(compteurX,
+                                        compteurY,
+                                        0)
+                          );
+                compteurX += 2 * TailleX / (3 * nbr_enemies);
             }
         }   
     }
 }
 
-    
-  
 
-void AfficherSbire(int lutin, int L, int H, struct liste_entite *l)
+void AfficherSbire (struct liste_entite* Liste,
+                    int                  lutin,
+                    int                  Largeur,
+                    int                  Hauteur)
 {
-    struct liste_entite *ml=l;
-    while(ml != NULL)
+    
+    struct liste_entite* pListe = Liste;
+    
+    while (pListe != NULL)
     {
-        afficherLutin(lutin,ml->enti.posx - L/2 + ErreurHitbox,ml->enti.posy - H/2 + ErreurHitbox);
-        ml=ml->suivant;
+        afficherLutin(lutin,
+                      pListe->entite.posx - Largeur / 2 + ErreurHitbox,
+                      pListe->entite.posy - Hauteur / 2 + ErreurHitbox);
+        pListe=pListe->suivant;
     }
 }
-
-  
diff --git a/Monstre/Monstre.h b/Monstre/Monstre.h
index 92f6213..f270bef 100644
--- a/Monstre/Monstre.h
+++ b/Monstre/Monstre.h
@@ -5,4 +5,4 @@ void DeplacementSbire(struct liste_entite*,int*,int);
 
 void LigneSbire(struct liste_entite**,int,int);
 
-void AfficherSbire(int,int,int,struct liste_entite*);
+void AfficherSbire(struct liste_entite*,int,int,int);
--
libgit2 0.21.2