Mine

#include <stdio.h>

#include <stdlib.h>


typedef struct jeu {

	int scoreJ;

	int scoreO;

	int *tab;
	
	int tour;
	
	int termine;
	
}jeu;



void init(jeu *n) {

	int i;

	n->scoreJ=0;

	n->scoreO=0;

	
	for(i=0;i<12;i++){

		n->tab[i]=4;

	}
	
	printf("Qui commence la partie? Entrez 0 pour Joueur et 1 pour Ordinateur\n");
	scanf("%d",&n->tour);
	
	n->termine=0;
}




void affichage(jeu *n){


	printf("_____________________________________\n");

	printf("|  %i  |  %i  |  %i  |  %i  |  %i  |  %i  |\n",n->tab[11], n->tab[10], n->tab[9], n->tab[8], n->tab[7], n->tab[6]);

	printf("|_____|_____|_____|_____|_____|_____|\n");

	printf("|  %i  |  %i  |  %i  |  %i  |  %i  |  %i  |\n",n->tab[0], n->tab[1], n->tab[2], n->tab[3], n->tab[4], n->tab[5]);

	printf("|_____|_____|_____|_____|_____|_____|\n");
	
	printf("\n\n Score du joueur:%d\n Score de l'ordinateur:%d",n->scoreJ, n->scoreO);
}



void prise_joueur(jeu *n){
     
     int trou_s=13;
     int trou;
     int nb_graines=0;
     while (trou_s<0 || trou_s>5){
         printf("Quel trou choisisez vous?");
         scanf("%d",&trou_s);
         if (n->tab[trou_s]==0) printf("Impossible de selectionner une case vide");
         }
     nb_graines=n->tab[trou_s];
     n->tab[trou_s]=0;
     trou=trou_s;
     while (nb_graines!=0){
           trou++;
           if(trou==12)trou=0;
           if(trou==trou_s)trou++;
           n->tab[trou]++;
           nb_graines--;
           }
     while (trou>5 && trou<12){
           if(n->tab[trou]==2 || n->tab[trou]==3){
                              n->scoreJ=n->scoreJ+n->tab[trou];
                              trou--;}
           else break;
           
           }        
     n->tour=1;
     }

int ia_attaque_hype(jeu *n){
     
     int i;
     int j;
     int k;
     int l;
     int nb_graines;
     double score[2];
     double score_ca[2] = {0,0};
     jeu *v;
     
     score[0]= 0;
     score[1]= n->scoreO-n->scoreJ;
     
     v=malloc(12*sizeof(jeu));
     
     for (i=6;i<12;i++){
         if (v->tab[i]==0)i++;
         v=n;
         
         nb_graines=v->tab[i];
         v->tab[i]=0;
         j=i;
         while (nb_graines!=0){
               j++;
               if(j==12)j=0;
               if(j==i)j++;
               v->tab[j]++;
               nb_graines--;
               }
         while (j>=0 && j<6){
               if(v->tab[j]==2 || v->tab[j]==3){
                                  v->scoreO=v->scoreO+v->tab[j];
                                  j--;}
               else break;
               
               }
         score_ca[1]=v->scoreO;
         for (k=0;k<6;k++){
             if (v->tab[k]==0)k++;
                     
             nb_graines=v->tab[k];
             v->tab[k]=0;
             l=k;
             while (nb_graines!=0){
                   l++;
                   if(l==12)l=0;
                   if(l==k)l++;
                   v->tab[l]++;
                   nb_graines--;
                   }
             while (l>=6 && j<12){
                   if(v->tab[l]==2 || v->tab[l]==3){
                                      v->scoreJ=v->scoreJ+v->tab[l];
                                      l--;}
                   else break;
                        
                   }
             if (score_ca[2]<v->scoreJ){
                score_ca[2]=v->scoreJ;
                }
             }
         
         if (score[2]<score_ca[1]-score_ca[2]){
            score[2]=score_ca[1]-score_ca[2];
            score[1]=i;
         }
         }
         
     return score[1];
     }                              

void prise_ordi(jeu *n){
     
     int trou_s;
     int trou;
     int nb_graines=0;
 
     trou_s=ia_attaque_hype(n);
 
     nb_graines=n->tab[trou_s];
     n->tab[trou_s]=0;
     trou=trou_s;
     while (nb_graines!=0){
           trou++;
           if(trou==12)trou=0;
           if(trou==trou_s)trou++;
           n->tab[trou]++;
           nb_graines--;
           }
     while (trou>=0 && trou<6){
           if(n->tab[trou]==2 || n->tab[trou]==3){
                              n->scoreO=n->scoreO+n->tab[trou];
                              trou--;}
           else break;
           
           }        
     n->tour=0;
     }
                              

void alternance(jeu *n){
     while (n->termine==0){
           affichage(n);
           if (n->tour==1){
              prise_ordi(n);}
           else prise_joueur(n);
           
           }
}



int main(){


jeu *n;
n=malloc(12*sizeof(jeu));
init(n);

alternance(n);

return 0;
}