diff --git a/neutron.c b/neutron.c
index 676c5b5..0280e72 100644
--- a/neutron.c
+++ b/neutron.c
@@ -8,50 +8,54 @@
 #define vert "\033[;32m"
 #define bleu "\033[;34m"
 
-#define green 0
-#define blue 1
-#define red 2
-#define empty -1
+#define green 0 //L'entier 0 correspond au neutron
+#define blue 1 //L'entier 1 correspond au pion bleu (Joueur Bleu)
+#define red 2 //L'entier 2 correspond au pion rouge (Joueur Rouge)
+#define empty -1 //L'entier -1 correspond à une case vide
 
+//Structure damier
 typedef struct d{
-    int tab[N][N];
+    int tab[N][N];//tableau d'entier dont chaque entier correspond à un pion selon les variables globales définies
     int indl; //indice de ligne du neutron
     int indc; //indice de colonne du neutron
 }damier;
 
 
-//fonction qui initialise un damier
+//Fonction qui initialise un damier
 damier init(){
   damier d;
-  int i,j;
+  int i,j;//indice de ligne et de colonne du champ tab dans le damier
 
   for(i=0;i<N;i++){
      for(j=0;j<N;j++){
-       d.tab[i][j]=-1;
+       d.tab[i][j]=-1;//On rempli le tableau de cases vides
      }
   }
   
   for(j=0;j<N;j++){
-    d.tab[0][j]=2;
+    d.tab[0][j]=2;//On rempli la première ligne de pions rouges
   }
   
   for(j=0;j<N;j++){
-    d.tab[4][j]=1;
+    d.tab[4][j]=1;//On rempli la première ligne de pions bleus
   }
   
   
-  d.tab[2][2]=0;
+  d.tab[2][2]=0;//On place le neutron au centre
 
-  d.indl=3;
-  d.indc=3;
+  d.indl=3;//On initialise l'indice de ligne du neutron
+  d.indc=3;//On initialise l'indice de colonne du neutron
 
   return d;
 }
 
-//fonction d'affichage d'un damier d donné
+//Fonction d'affichage d'un damier d donné
 void affichage(damier d){
     int i,j;
+  
+    printf("\n");
     for (i=0;i<N;i++){
+        printf("%d   ",N-i);//Affiche les numéros de lignes
          for (j=0;j<N;j++){
              if (d.tab[i][j]==green){
 	       printf("%s%s   %s ",vert,reverse,reset);
@@ -66,24 +70,30 @@ void affichage(damier d){
                  printf("    ");
              }
          }
-         printf("\n");
+         printf("\n\n");
     }
+    printf("    ");
+    for (j=0;j<N;j++){
+        printf(" %d  ",j+1);}//Affiche les numéros de colonnes
+    printf("\n\n");
 }
 
 
 
     
 
-/* dir : Donnée (donne la direction voulu par le joueur)
-   i,j : Données,indice de ligne et de colonne du pion qu'on veut déplacer
-   d: D/R
+/* dir : Donnée (donne la direction entre 1 et 8 voulu par le joueur)
+   i,j : Données, indice de ligne et de colonne du pion qu'on veut déplacer
+   d: D/R : Un damier donnée qu'on modifiera selon le déplacement voulu par le joueur
 */
 
+//Fonction qui déplace un pion à la position i,j du damier d donné vers une direction dir donnée
 void dep(int i,int j,int dir,damier *d){
-  int temp;
+  int temp;//Variable temporaire
   i=N-i;
-  j=j-1;
+  j=j-1;//remise des indices de lignes et de colonnes du pion à déplacer en indice de language C
   
+  //Pour chaque direction donnée, on effectue un déplacement précis du pion choisi
   if (dir==1){
     while ((i>=1) && ((d->tab[i-1][j])==empty)){
       temp=d->tab[i][j];
@@ -167,15 +177,21 @@ void dep(int i,int j,int dir,damier *d){
        
 }
 
-// Fonction qui renvoie 0 si le déplacement n'est pas valide et 1 sinon  
+/* d : damier donné 
+   i,j,dir : entiers donnés*/
+
+//Fonction qui renvoie 0 si le déplacement d'un pion d'indices données i,j n'est pas valide (le déplacement vers la direction dir n'est pas possible pour le pion donné) et 1 sinon. 
+
 int valide(int i,int j,int dir,damier d){
      int valide;
      i=N-i;
-     j=j-1;
+     j=j-1;//remise des indices de lignes et de colonnes du pion à déplacer en indice de language C
+  
   
     
     valide=1;
     
+    //Pour chaque direction, on met valide à 0 si selon cette direction le pion est sur le bord du tableau ou la case à côté n'est pas vide 
     if(dir==8 && (i==0 || j==0 || (d.tab[i-1][j-1]!=empty)) ){
         valide=0;}
     else if(dir==1 && (i==0 || d.tab[i-1][j]!=empty)){ 
@@ -192,156 +208,239 @@ int valide(int i,int j,int dir,damier d){
         valide=0;}
     else if(dir==7 && (j==0 || d.tab[i][j-1]!=empty)){ 
         valide=0;}
-    /*else if (1<=dir || dir>=8){
-        valide=0;}*/
     return valide==1;
 }
 
-// 1 si joueur est bleu et 2 si le joueur est rouge
-//renvoie 0 si perd et 1 si gagne
+
+
+/* d : un damier donné  
+joueur :entier donné, 1 si le joueur est bleu et 2 si le joueur est rouge*/
+
+//Fonction qui renvoie 1 si le joueur perd et 0 si il ne perd pas. On dit qu'un joueur perd lorsque le neutron ne peut plus se déplacer, ou aucun de ses pions ne peut plus se déplacer (aucun déplacement n'est valide pour tous ses pions) ou encore le neutron est dans le camp de l'autre joueur.
 int perd(int joueur,damier d){
-     int i=d.indl;
-     int j=d.indc;
-     int c=1;
-     int perd=0;
+     int i,j;//indice de ligne et de colonne du champ tableau dans le damier donné
+     int c=1;//donne la direction de déplacement du pion
+     int p=0;//si le joueur perd p=1, sinon p=0
+     int cpt; //compte le nomrbe de pions qui ne peuvent pas bouger 
+     
      
+    //TEST SI LE NEUTRON PEUT SE DÉPLACER
+    
+    while(c<=8 && valide(d.indl,d.indc,c,d)==0){
+         c++;}
    
+    if(c==9){
+         p=1;}   
+
+
      
-     //Test si les pions du joueur bleu peuvent se déplacer
-     if(joueur==blue){
-         for(i=0;i<N;i++){
+     // TEST SI LES PIONS DU JOUEUR BLEU PEUVENT SE DÉPLACER
+    
+     cpt=0;
+     if ( p!=1 && joueur==blue){
+           //On regarde si chaque déplacement de 1 à 8 peut être fait ou non pour le pion bleu à la position i,j
+           for(i=0;i<N;i++){
              for(j=0;j<N;j++){
                  if(d.tab[i][j]==blue){
-                        while(c<=8 && valide(i,j,c,d)==0){
+                        c=1;
+                        while(c<=8 && valide(N-i,j+1,c,d)==0){
                             c++;}
-     
                         if(c==9){
-                            perd=1;}
-                        else { perd=0;}
+                            cpt++;}
                     
                  }
              }
          }
-         if(d.indl==0) {
-             perd=1;
+         
+         //Le joueur bleu perd si tous ses pions ne peuvent pas se déplacer ou si le neutron est la ligne adverse
+         if(cpt==5 || d.indl==5) {
+             p=1;
          }
+         
      }
+    
      
-     //Test si les pions du joueur rouge peuvent se déplacer
-     else if(joueur==red){
+     // TEST SI LES PIONS DU JOUEUR ROUGE PEUVENT SE DÉPLACER
+     
+     else if(p!=1 && joueur==red){
+         //On regarde si chaque déplacement de 1 à 8 peut être fait ou non pour le pion rouge à la position i,j
          for(i=0;i<N;i++){
              for(j=0;j<N;j++){
                  if(d.tab[i][j]==red){
-                        while(c<=8 && valide(i,j,c,d)==0){
+                        c=1;
+                        while(c<=8 && valide(N-i,j+1,c,d)==0){
                             c++;}
-     
+                        
+                        //Si les 8 directions n'ont pas été valides, on comptes le pion comme non déplacable
                         if(c==9){
-                            perd=1;}
-                        else { perd=0;}
+                            cpt++;}
+                     
+                       
                  }
              }
          }
-         if(d.indl==4) {
-             perd=1;
+         
+         //Si les cinq pions rouges ne peuvent pas se déplacer ou si le neutron est dans la ligne adverse, alors le joueur rouge perd
+         if(cpt==5 || d.indl==1) {
+             p=1;
+          
          }
      }
-                
-    
-    //TEST SI LE NEUTRON PEUT SE DÉPLACER
-    c=1;
-    while(c<=8 && valide(i,j,c,d)==0){
-         c++;}
-     
-    if(c==9){
-         perd=1;}   
-    
-    return perd;
-    
-    
+
+        return p;        
+       
 }
-         
 
 
-    
-//Défini un coup joué
 
-void tour(int joueur,damier *d){
-    int ind=d->indl;
-    int col=d->indc;
-    int dir;
-    int v;
-    int i,j;
-    
-    do{
-      printf("saisir un déplacement valide TOUR1\n");
+
+/*joueur : D
+  d : D/R
+  p : D/R
+*/
+
+//Un joueur donné déplace le neutron d'un damier donné. Après déplacement, on renvoie p qui dit s'il a perdu ou pas.
+void tourNeutron(int joueur,damier *d,int *p){
+    int ind=d->indl;// ind indice de ligne du neutron dans le damier donné
+    int col=d->indc;// col indice de colonne du neutron dans le damier donné
+    int dir;// donne la direction de déplacement voulue
+    int v;//stock la validité d'une direction donnée
+    int i,j;// indice de  ligne et de colonne du champ tableau dans le damier
+    int b; //booléen pour la boucle tant que
+   
+     if (perd(joueur,*d)==1) *p=1;//On teste si le joueur perd avant de commencer son tour
+     
+     else {
+     //Tant que la direction donnée n'est pas possible, on redemande une autre direction valide
+     do{
+      printf("Saisir un déplacement valide du NEUTRON\n");
       scanf("%d",&dir);
       v=valide(ind,col,dir,*d);
+      }while(v==0);
       
-    }while(v==0);
-    dep(ind,col,dir,d);
-   
+     dep(ind,col,dir,d);
+     affichage(*d);
+     
+     //Réinitialisation des coordonnées du neutron
+    i=0;
+    b=0;
+    while (i<N && b==0){
+        j=0;
+        while (j<N && b==0){
+            if ((d->tab[i][j])==green){
+                b=1;
+            }
+            else j++;
+        }
+        if(j==N) i++;
+    }
+    
+    ((*d).indl)=N-i;
+    ((*d).indc)=j+1;
+  
+     }
+  
+}
+
+
+
+/*joueur : D
+  d : D/R
+  p : D/R
+*/
+
+//Un joueur donné déplace le pion d'un damier donné. Après déplacement, on renvoie p qui dit s'il a perdu ou pas.
+void tourPion(int joueur,damier *d,int *p){
+    int dir;// donne la direction de déplacement voulue
+    int v; //stock la validité d'une direction donnée
+    int t;
+    int i,j;// indice de  ligne et de colonne du champ tableau dans le damier
+    
+    if (perd(joueur,*d)==1) *p=1;//On teste si le joueur perd avant de commencer son tour
+    
+    
+    else {
+        //Tant que les indices donnés ne correspondent pas à un pion du joueur, on redemande de nouveaux indices
+        do{
+            printf("Saisir l'indice de ligne et de colonne du PION\n");
+            scanf("%d,%d",&i,&j);
+            t=(d->tab[N-i][j-1]);
+        }while(t!=joueur);
+    
+    //Tant que la direction donnée n'est pas possible, on redemande une autre direction valide
     do{
-      printf("saisir un déplacement valide TOUR2\n");
+      printf("Saisir un déplacement valide du PION\n");
       scanf("%d",&dir);
       v=valide(i,j,dir,*d);
       
     }while(v==0);
     
-    printf("Saisir l'indice de ligne et de colonne du pion\n");
-    scanf("%d,%d",&i,&j);
     
     
     dep(i,j,dir,d);
     affichage(*d);
+    
+    }
 }
     
     
 
 int main(){
-    int i; //indice de ligne
-    int j; //indice de colonne
-    int dir;//indice de déplacement
-    int v;
-   
+    int p=0;
     
     damier d;
     d=init();
     affichage(d);
     printf("\n\n");
     
-    
-    printf("Indice de ligne et de colonne du pion\n");
-    scanf("%d,%d",&i,&j);
-    do{
-      printf("saisir un déplacement valide MAIN\n");
-      scanf("%d",&dir);
-      v=valide(i,j,dir,d);
-      
-    }while(v==0);
-    
-    dep(i, j, dir, &d);
-    affichage(d);
-    
+    printf("Bleu joue!\n");
+    tourPion(blue,&d,&p);//Le joueur bleu effectue le premier déplacement de son pion
+  
+
    
-    while (perd(blue,d)==1 && perd(red,d)==1){
-        tour(red,&d);
-        affichage(d);
+    while (p==0){//Tant qu'aucun des deux joueurs ne perd,la partie continue.
+        printf("%s%s  Rouge joue!  %s\n",rouge,reverse,reset);
+        tourNeutron(red,&d,&p);//Le joueur rouge déplace le neutron
+         if (p==1) {
+             printf("%s Joueur rouge ne peut plus déplacer le neutron, tu perds !  %s\n\n%s%s  FELICITATION, JOUEUR BLEU GAGNE !!!  %s\n\n",rouge,reset,vert,reverse,reset);
+             break;//On arrête la boucle dès que le joueur rouge ne peut plus bouger le neutron
+         }
+         
+        if (d.indl==5) {printf("%sVous avez ramener le neutron dans votre camp%s\n%s%s  FELICITATION, JOUEUR ROUGE GAGNE !!!  %s\n\n",rouge,reset,vert,reverse,reset);
+        break;//On arrête la boucle quand rouge a ramené le neutron dans son camp
+        }
+        
+        tourPion(red,&d,&p);//Le joueur rouge déplace le pion qu'il a choisi
+        if (p==1) {
+             printf("%s Joueur rouge ne peut plus déplacer ses pions, tu perds !  %s\n\n%s%s  FELICITATION, JOUEUR BLEU GAGNE !!!  %s\n\n",rouge,reset,vert,reverse,reset);
+             break;//On arrête la boucle dès que le neutron est encerclé
+        }
+        
+        printf("\n\n");
+        
+        printf("%s%s  Bleu joue!  %s\n",bleu,reverse,reset);
+        tourNeutron(blue,&d,&p);    //Le joueur bleu déplace le neutron
+        if (p==1) {
+             printf("%s Joueur bleu ne peut plus déplacer le neutron, tu perds !  %s\n\n%s%s  FELICITATION, JOUEUR ROUGE GAGNE !!!  %s\n\n",bleu,reset,vert,reverse,reset);
+             break;//On arrête la boucle dès que le neutron est encerclé
+        }
+        
+        if (d.indl==5) {printf("%sVous avez ramener le neutron dans votre camp%s\n%s%s  FELICITATION, JOUEUR BLEU GAGNE !!!  %s\n\n",bleu,reset,vert,reverse,reset);
+        break;//On arrête la boucle quand rouge a ramené le neutron dans son camp
+        }
+        
+        tourPion(blue,&d,&p);//Le joueur rouge déplace le pion qu'il a choisi
+        if (p==1) {
+             printf("%s Joueur bleu ne peut plus déplacer ses pions, tu perds !  %s\n\n%s%s  FELICITATION, JOUEUR ROUGE GAGNE !!!  %s\n\n",bleu,reset,vert,reverse,reset);
+             break; //On arrête la boucle dès que le joueur bleu ne peut plus bouger ses pions
+        }
         printf("\n\n");
-        tour(blue,&d);
-        affichage(d);
-    }
-    
-    if (perd(blue,d)==0){
-        printf("Joueur Bleu gagne\n");
-    }
-    
-    else if (perd(red,d)==0){
-        printf("Joueur Rouge gagne\n");
     }
+ 
 
   return 0;
 }
   
 
-         
+
          
--
libgit2 0.21.2