#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/*******************************************/
/*             prototypes                  */
/*******************************************/

int vainqueur(int pli[4],int atout);
void joue(int p1[8],int pli[4], int atout,int no,int pri);
void affiche(int a);
void init(int p0[8],int p1[8],int p2[8],int p3[8]);
void humain(int p0[8], int pli[4],int atout,int no);
/*******************************************/
/*         variables globales              */
/*******************************************/

int tab[4][8]={{-1,-1,-1,-1,-1,-1,-1,-1},
               {-1,-1,-1,-1,-1,-1,-1,-1},
               {-1,-1,-1,-1,-1,-1,-1,-1},
               {-1,-1,-1,-1,-1,-1,-1,-1}};

/************************************************/
/*    plus grande                               */
/*           recherche la carte la plus grande  */
/*           qui n'est ni atout ni maitre       */
/*            sinon carte maitre la plus petite */
/*            sinon atout le plus petit         */
/************************************************/
int plusgrande(int jouable[8],int atout)
{
   int meilleur;
   int i;
   int j;
   int k;

   i=0;
   j=0;
   k=0;
   while(i<8)                           /* on compte les atouts */
      {  if((jouable[i]/100)== atout)
         {j++;}

         if( jouable[i]!=-100)             /* on compte les cartes jouables */
            {k++;}

         i++;
      }

   if(j<k)        /* si au moins une carte n'est pas atout */
      {  i=0;
         while(i<8)                                   /* on enleve tous les atouts de jouable */
            {
               if((jouable[i]/100)==atout)
                  {  jouable[i]=-100;}

             i++;}

          i=0;
          j=0;
          k=0;
          while(i<8)                           /* on compte les cartes maitres */
         {  if(maitre(jouable[i],atout)==1)
            {j++;}

            if( jouable[i]!=-100)             /* on compte les cartes jouables */
            {k++;}

         i++;
         }

         if(j<k)                           /* au moins une carte n'est pas maitre */
            {
               i=0;
               while(i<8)                                   /* on enleve toutes  les cartes maitres */
                {
                  if(maitre(jouable[i],atout)==1)
                     {  jouable[i]=-100;}
                i++;}

             /*  on recherche la plus grande des cartes pas maitres */
            meilleur=-1;
            i=0;
            j=0;
            while(i<8)
               {  if ((valeur(jouable[i],atout)>meilleur) && (jouable[i]>-1))
                  {  meilleur=valeur(jouable[i],atout);
                     j=i;
                     }
               i++;}
               return jouable[j];
			    }
         else                              /*toutes les cartes sont maitres*/
            {
               meilleur=100;
            i=0;
            j=0;
            while(i<8)
               {  if ((valeur(jouable[i],atout)<meilleur) && (jouable[i]>-1))
                  {  meilleur=valeur(jouable[i],atout);
                     j=i;
                     }
               i++;}
               return jouable[j];

            }




       }
   else           /* si toutes les cartes sont de l'atout on renvoie la + petite sauf si on a le 9 sec apres */

      {      i=0;
         	 j=0;
             k=0;
           	 while(i<8)
                {  if((jouable[i]/100)==atout)
                    {  j++;
                       if(jouable[i]==(atout*100 + 5))   /* si on a le 9 */
                         { k=1;

                         }

                    }
                i++;
                }

        if( (k==1) && (j==2) && (tab[atout][3]<10))  /* si on a 2 atouts dont le 9 */
            {  k=(atout*100 + 5);
               return k;
               }                                         /*et que le valet n'a pas ete joue*/
        else
           {

              meilleur=100;
            i=0;
            j=0;
            while(i<8)
               {  if ((valeur(jouable[i],atout)<meilleur)&& (jouable[i]>-1))
                  {  meilleur=valeur(jouable[i],atout);
                     j=i;
                     }
               i++;}
               return jouable[j];
            }
      }
}


/***********************************************/
/*               pluspetite                    */
/*                                             */
/*             renvoie la carte la plus petite */
/*(en essayant de ne pas creer) un 10 sec      */
/***********************************************/
int pluspetite(int jouable[8],int atout)
{int bool;
 int i;
 int j;
 int k;
 int couleur;
 int meilleur;
 bool=0;

 while (bool==0)
{

   i=0;
   j=0;
   k=0;
   while(i<8)                           /* on compte les atouts */
      {  if((jouable[i]/100)== atout)
         {j++;}

         if( jouable[i]!=-100)             /* on compte les cartes jouables */
            {k++;}

         i++;
         }

   if(j==k)        /* si tout est atout on joue la plus petite*/
     {
          meilleur=100;
            i=0;
            j=0;
            while(i<8)
               {

               			if ((valeur(jouable[i],atout)<meilleur) && (jouable[i]>-1))
                  		{  meilleur=valeur(jouable[i],atout);
                     	j=i;
                        }
               i++;}
               return jouable[j];



     }
     else

      {  i=0;
         while(i<8)                                   /* on enleve tous les atouts de jouable */
            {
               if((jouable[i]/100)==atout)
                  {  jouable[i]=-100;}

             i++;
             }

          meilleur=100;               /* on cherche la plus petite */
            i=0;
            j=0;
            while(i<8)
               {  if ((valeur(jouable[i],atout)<meilleur) && (jouable[i]>-1))
                  {  meilleur=valeur(jouable[i],atout);
                     j=i;
                     }
               i++;}
                        /* la plus petite est ds j*/
            i=0;
            k=0;
            while(i<8)
            {   if((jouable[i]==((jouable[j]/100)*100 + 4)) && (i!=j))
                { k=1;
                }
            i++;
            }

            if((k==0) || ((jouable[j]%100)==4))
            {return jouable[j];}           /*si la carte la plus petite ne correspond pas à un 10 ou que c'est un 10 c'est bon*/
            else   /* si on a un 10 de la meme couleur */
            {  i=0;
               k=0;
            	while(i<8)
            	{   if((jouable[i]==((jouable[j]/100)*100)))
                		{ k=1;
                		}
            	i++;
            	}

               if ((k==1) || (tab[jouable[i]/100][jouable[i]%100]>9))
               {return jouable[j];}      /* si on a l'as ou que l'as a ete joue  c'est bon */
               else            /* si l'as est inconnu*/
               {      i=0;
                      k=0;
            	       while(i<8)
            	       {   if((jouable[i]/100)==(jouable[j]/100))
                		     { k++;}
            			  i++;
            			  }
                       if(k>2)
                       {return jouable[j];}  /* si on a encore une carte de la meme couleur(au - 3) c'est bon*/
                       else
                       {i=0;
                        k=0;
                        while(i<8)
                        {   if(((jouable[i]/100)!= (jouable[j]/100)) && (jouable[i]!=-100))
                             {k=1;}
                          i++;
                        }

                        if(k==0)           /* si on a qu'une seule couleur c'est bon */
                        {return jouable[j];}
                        else                      /* si on a d'autres couleurs on enleve celle que l'on vient de traiter*/
                        {couleur=(jouable[j]/100);        /* et on boucle grace a bool */
                          i=0;
                          while(i<8)
                          {   if((jouable[i]/100)==couleur)
                              {jouable[i]=-100;}
                          i++;
                          }

                        }



                       }

               }

            }

      }
}
}


/***********************************************************/
/*        maitre                                           */
/*            fonction qui a une carte en entrée et        */
/*            renvoie 1 si la carte est maitre  0 sinon    */
/***********************************************************/
int maitre(int carte,int atout)
{int meilleur;
 int couleur;
	if((carte /100)== atout)     /* si c'est de l'atout */
	{                            /* on va rechercher la carte la + forte qui reste a jouer a l'atout */
      if (tab[atout][3]<4)           /* y'a encore le valet*/
      {meilleur = atout*100 + 3;
      }
      else
      {	if (tab[atout][5]<4)           /* 9 */
      	{meilleur = atout*100 + 5;}
         else
         {  if (tab[atout][0]<4)           /* AS */
            {meilleur = atout*100 + 0;}
            else
            {	if (tab[atout][4]<4)        /* 10 */
               {meilleur = atout*100 + 4;}
               else
               {   if (tab[atout][1]<4)        /* Roi */
                   {meilleur = atout*100 + 1;}
                   else
                   {  if (tab[atout][2]<4)      /* Dame  */
                      {meilleur = atout*100 + 2;}
                      else
                      {   if (tab[atout][6]<4)        /* 8 */
                          {meilleur = atout*100 + 6;}
                          else                        /* 7 */
                          {meilleur = atout*100 + 7;}
                      }
                   }
               }
            }
         }
      }
	}
   else          /* si c'est pas de l'atout */
   {couleur = carte /100;

     if (tab[couleur][0]<4)           /* y'a encore l'as*/
      {meilleur = couleur*100 + 0;}
      else
      {	if (tab[couleur][4]<4)           /* 10 */
      	{meilleur = couleur*100 + 4;}
         else
         {  if (tab[couleur][1]<4)           /* roi */
            {meilleur = couleur*100 + 1;}
            else
            {	if (tab[couleur][2]<4)        /* dame */
               {meilleur = couleur*100 + 2;}
               else
               {   if (tab[couleur][3]<4)        /* valet */
                   {meilleur = couleur*100 + 3;}
                   else
                   {  if (tab[couleur][5]<4)      /* 9  */
                      {meilleur = couleur*100 + 5;}
                      else
                      {   if (tab[couleur][6]<4)        /* 8 */
                          {meilleur = couleur*100 + 6;}
                          else                        /* 7 */
                          {meilleur = couleur*100 + 7;}
                      }
                   }
               }
            }
         }
      }
   }

 if(meilleur==carte)
 {return 1;}
 else
 {return 0;}

}

/***********************************************************/
/*        valeur                                           */
/*            fonction qui a une carte en entrée et        */
/*            renvoie la valeur de la carte                */
/***********************************************************/
int valeur(int carte,int atout)
{int points=0;

   if(carte!=-100)
       {
      if ((carte % 100)==3)           /* valet*/
      {     if((carte / 100)==atout)
            {points=20;}
            else
            {points=2;}
      }
      else
      {	if ((carte % 100)==5)           /* 9 */
      	{  if((carte /100) == atout)
              {points = 14;}
         }
         else
         {  if ((carte % 100)==0)           /* AS */
            {points = 11;}
            else
            {	if ((carte % 100)==4)        /* 10 */
               {points = 10;}
               else
               {   if ((carte % 100)==1)        /* Roi */
                   {points = 4;}
                   else
                   {  if ((carte % 100)==2)      /* Dame  */
                      {points = 3;}

                   }
               }
            }
         }
      }
     }
  else
     {points=-1;}
  return points;


}
/*******************************************/
/*       joueur humain joue                */
/*******************************************/
void humain(int p0[8], int pli[4],int atout,int no)
{int t;
int carte;
int i;
int bool;

bool = 0;

while(bool == 0)
{
printf("voici le pli\n");
i=0;
while(i<no)
{printf("%d )     ",i);
 affiche(pli[i]);
 i++;
 }

printf("qu'est ce tu fous ?\n");
t=0;

 while (t<8)
{printf("%d ) ",t);
affiche(p0[t]);
t++;
}
 bool = 1;
 printf("n° carte  ??\n");
 scanf("%d",&carte);

 if (p0[carte]==-100)
 {bool = 0 ;
 }


 if(possible(pli,p0,atout,carte,no) == 0)
 {bool = 0;}





}
 pli[no]=p0[carte];
 p0[carte] = -100;
}

/****************************************************/
/*   la carte peut elle etre jouée ?  1 oui   0 non */
/****************************************************/
int possible(int pli[4],int p0[8],int atout,int carte,int no)
{
	int i;
	int j;
	int k;
   int pli2[4];


	if (pli[0]==-100)
		{return 1;}
   else
   	{ if((pli[0] / 100)!= atout)    /* si la couleur demandée n'est pas de l'atout */
     		{
     		if ((p0[carte]/100) == (pli[0]/100))  /* si la carte jouée correspond a la bonne couleur */
        		{return 1;}
         else                             /* si la catre jouée n'est pas de la bonne couleur */
        		{ i=0;
          	  j=0;
        				while (i<8)
        				{
        					if ((p0[i]/100)==(pli[0]/100))
        					{j++;}

           			 i++;
          		    }
           if(j>0)                         /* alors qu'on a la bonne couleur */
           {return 0;
           }
           else                            /* si on a pas la bonne couleur*/
           {




        			if ((p0[carte]/100) == atout)  /* si on joue de l'atout */
        			{
                  i=0;
                  j=0;
                  while(i<4)
                  { if((pli[i] / 100) == atout)
                    {j++;}
                    i++;
                  }

                  if(j>0)      /* si qqun a coupe */
                  {i=vainqueur(pli,atout);
                   if(i== (no - 2))        /* si le partenaire est maitre c'est bon*/
                   {return 1;}
                   else                    /* si le partenaire n'est pas maitre */
                   {
                   /************************/
                   i=0;
        					while(i<4)
        					{pli2[i]=pli[i];
        					i++;
                     }
        					i=0;
        					j=0;
        					while(i<8)
        					{pli2[no]= p0[i];
        					k=vainqueur(pli2,atout);
          				if (k==no)
          				{j++;
          				}
          				i++;
        					}

        					if(j>0) /* si on peut monter*/
        					{ pli2[no]=p0[carte];
          				k= vainqueur(pli2,atout);
          				if(k==no)  /* et qu'on joue une carte plus forte c'est bon */
          				{return 1;}
          				else       /* et qu'n joue une carte moins forte c'est pas bon */
          				{return 0;}

        					}
        					else        /* si on peut pas monter */
       				   {return 1;}
                   /************************/


                   }


                  }
                  else         /* si personne n'a coupe c'est bon*/
                  {return 1;}
                   



               }
               else
               {i=0;
                j=0;
        		    while (i<8)
        		    {
        			if ((p0[i]/100)==atout)
        			{j++;}

               i++;
                }
                if (j>0)               /* si on a de l'atout (mais qu'on joue autre chose) */
                {j=vainqueur(pli,atout);
                 if(j == (no-2))        /* si le partenaire est maitre c'est bon */
                 {return 1;}
                 else                  /* si le patrenaire n'est pas maitre c'est pas bon*/
                 {return 0;}

                }
                else                   /* si on a pas d'atout c'est bon */
                {return 1;}


               }

            }



           }

        }
        else                    /*si la couleur demandée est de l'atout */
        {i=0;
        while(i<4)
        {pli2[i]=pli[i];
        i++;
        }
        i=0;
        j=0;
        while(i<8)
        {pli2[no]= p0[i];
        k=vainqueur(pli2,atout);
          if (k==no)
          {j++;
          }
          i++;
        }

        if(j>0) /* si on peut monter*/
        { pli2[no]=p0[carte];
          k= vainqueur(pli2,atout);
          if(k==no)
          {return 1;}
          else
          {return 0;}

        }
        else        /* si on peut pas monter */
        { i=0;
        j=0;
        while(i<8)
        {if ((p0[i]/100)==atout)
          {j++;
          }
        i++;
        }
        if (j>0)   /* et qu'on a de l'atout  */
        { if((p0[carte]/100) == atout)
        		{return 1;}
           else
            {return 0;}

        }
        else       /* et qu'on a pas d'atout */
        {return 1;}



        }



        }
}
}
/*******************************************/
/*    initialisation de la donne           */
/*******************************************/
void init(int p0[8],int p1[8],int p2[8],int p3[8])
{

int i;
int j;
int k=0;

while(k!=8)
{

  i = rand()%4;
  j = rand()%8;
  if(tab[i][j]==-1)
   {
   p0[k]=i*100+j ;
    tab[i][j]=0;
   k++;
   }
}
k=0;
while(k!=8)
{
  i = rand()%4;
  j = rand()%8;
  if(tab[i][j]==-1)
   {
   p1[k]=i*100+j ;
    tab[i][j]=1;
   k++;
   }
}
k=0;
while(k!=8)
{
  i = rand()%4;
  j = rand()%8;
  if(tab[i][j]==-1)
   {
   p2[k]=i*100+j ;
    tab[i][j]=2;
   k++;
   }
}
k=0;
while(k!=8)
{
  i = rand()%4;
  j = rand()%8;
  if(tab[i][j]==-1)
   {
   p3[k]=i*100+j ;
    tab[i][j]=3;
   k++;
   }
}


}

/*******************************************/
/*   affichage d'une carte                 */
/*******************************************/

void affiche(int a)
{
 int tmp;

 if(a>-1)
 {
 tmp = a/100;
   switch (tmp)
      {   case 0  : printf("Coeur     ");
      				 break;
      	 case 1  : printf("Carreaux  ");
                   break;
        	 case 2  : printf("Trefle    ");
                   break;
       	 case 3  : printf("Pique     ");
                   break;

     }



   tmp = a%100;
    switch (tmp)
      {   case 0  : printf("As\n");
      				 break;
      	 case 1  : printf("Roi\n");
                   break;
        	 case 2  : printf("Dame\n");
                   break;
       	 case 3  : printf("Valet\n");
                   break;
        	 case 4  : printf("10\n");
                   break;
          case 5  : printf("9\n");
      				 break;
      	 case 6  : printf("8\n");
                   break;
        	 case 7  : printf("7\n");
                   break;


     }
  }
  else
  {printf("\n");}
}
/********************************************/
/*      selectionne la carte à jouer CPU    */
/********************************************/
void joue(int p1[8],int pli[4], int atout,int no,int pri)         /* pri=0 ou pri=2 si le joueur ou son c*/
{
int p=0 ;                                                             /*   1 ou 3 sinon  */
int a=-1 ;
int b=0 ;
int i;
int j=0;

int jouable[8] ;


while ( j < 8 )          /* initialisation de jouable */
{
  jouable[j]=-100 ;
  j++ ;
}

j=0;
i=0;


while( i < 8)                   /* selectionne les cartes jouables */
{
  if ((possible(pli,p1,atout,i,no) == 1) && (p1[i]>-1))
    { jouable[j] = p1[i] ;
      j++ ;
    }
  i++ ;
}
j=0;
while  ( j<8)           /*jouable[j] > -1 */
{
    if(jouable[j]>-1)

    {

     if (pli[0] != -100)          /* si le joueur n'est pas le premier */
     {

             /* on regarde si le joueur a pris ou son coequipier */


              if((pli[0] / 100)!= atout)    /* si la couleur demandée n'est pas de l'atout */
              {

                 p=vainqueur(pli,atout);
                 if((p == (no-2)) && (maitre(jouable[no-2],atout) == 1))              /* si mon partenaire est maitre et le restera*/
                 {
                      if ((jouable[j]/100) != atout)  /* si la carte n'est pas de l'atout */
                      {
                           if((pli[0] / 100) != (jouable[j] / 100)) /* si la carte est de la couleur deman*/
                           {
                              if ( jouable[j] == plusgrande(jouable,atout)) /* si c'est la plus grande */
                              {
                                 a = jouable[j] ;
                                 b = 10 ;
                              }
                           }
                           else                                 /* si la carte n'est pas de la couleur dem*/
                           {
                              if (plusgrande(jouable,atout) == jouable[j] )  /* is c'est la + grande */
                              {
                                 a = jouable[j] ;
                              }
                           }
                      }
                      else                            /* la carte n'est pas de l'atout */
                      {
                           if ( b < 10 )
                           {
                               if (pluspetite(jouable,atout) == jouable[j] ) /* si c'est la + petite */
                               {
                                  a = jouable[j] ;
                               }
                           }
                      }
                 }
                 else                     /* si le partenaire n'est pas maitre */
                 {
                     if ((jouable[j]/100) != atout)  /* si la carte n'est pas de l'atout */
                     {
                         if ( maitre(jouable[j],atout) == 1)  /* si la carte est maitre */
                         {
                            a = jouable[j] ;
                            b = 10 ;
                         }
                         else
                         {
                            if (pluspetite(jouable,atout) == jouable[j])      /* si c'est la plus petite */
                            {
                               if (b < 10)
                               {
                                  a = jouable[j] ;
                               }
                            }
                         }
                     }                              /* si la carte est de l'atout */
                     else
                     {
                        if ( pluspetite(jouable,atout) == jouable[j] )
                        {
                            a = jouable[j] ;
                        }
                     }
                 }

              }
              else      /* si c'est de l'atout demandé */
              {
                 if ( (jouable[j]/100) == atout )            /* si la carte est de l'atout */
                 {
                   if ( maitre(jouable[j],atout) == 1 )     /* si c'est maitre */
                   {
                      a = jouable[j] ;
                      b = 10 ;
                   }
                   else
                   {
                       if (pluspetite(jouable,atout) == jouable[j])
                       {
                          a = jouable[j] ;
                       }
                   }
                 }
                 else                                                  /* si la carte n'est pas de l'atout */
                 {
                     if (pluspetite(jouable,atout) == jouable[j])      /* si c'est la plus petite */
                     {
                        if (b< 10)
                        {
                           a = jouable[j] ;
                        }
                     }
                 }
               }

          /********************************/


      }
      else                             /* si le joueur est le premier */
      {

         if ((pri==0) || (pri==2) || (pri==4))       /* si le joueur a pris */
          {

              if ((jouable[j]/100) == atout)  /* si la carte est de l'atout */
                 {
                   if ( maitre(jouable[j],atout) == 1 )   /* si la carte est maitre a l'atout */
                      {
                        a = jouable[j] ;
                      }

                   else
                      {
                         if (pluspetite(jouable,atout) == jouable[j])  /* si la carte est la plus basse */
                            {
                              if ( a == -1)
                                 {
                                    a = jouable[j] ;
                                    b=10 ;
                                 }
                            }
                      }
                 }
              else
                         /* si la carte n'est pas de l'atout */
                 {
                    if ( maitre(jouable[j],atout) == 1 )    /* si la carte n'est pas un atout mais qu'elle est maitre */
                       {
                          if (b < 10)
                          {
                             a = jouable[j] ;
                             b=9 ;
                          }
                       }
                    else
                       {
                          if ( pluspetite(jouable,atout) == jouable[j])    /* si elle n'est pas maitre on joue la plus petite */
                             {
                               if (b < 9)
                               {
                                  a = jouable[j] ;
                               }
                             }
                       }

                 }

         }
         else     /* si le joueur n'a pas pris */
         {
            if ((jouable[j]/100) != atout )       /* si la carte n'est pas de l'atout */
            {
               if ( maitre(jouable[j],atout) == 1 )  /* si la carte est maitre */
               {
                   a=jouable[j] ;
                   b=10 ;
               }
               else                        /* si la carte n'est pas maitre */
               {
                   if ( pluspetite(jouable,atout) == jouable[j])     /* si c'est la plus petite */
                   {
                      if(b < 9)
                      {
                         a = jouable[j] ;
                         b=9 ;
                      }
                   }
               }
            }
            else
            {
               if (b < 8)
               {
                   if ( maitre(jouable[j],atout) == 1 )  /* si la carte est maitre */
                   {
                       a = jouable[j] ;
                   }
                   else
                   {
                      if ( pluspetite(jouable,atout) == jouable[j])     /* si c'est la plus petite */
                      {
                          a = jouable[j] ;
                      }
                   }
               }
            }
         }


   }
  } 
j++;
}

/* ici il faut que i (0..7) designe la carte à jouer */
pli[no] = a;  /* on joue la carte choisie */

i=0 ;
while ( p1[i] != a )    /* on cherche la cart que l'on a jouée */
     {
         i++ ;
     }
         p1[i]   = -100;     /* on enleve la carte de la main */
}


/*********************************************/
/*    cherche le vainqueur d'un pli          */
/*********************************************/
int vainqueur(int pli[4],int atout)
{
 int points[4];
 int couleur;
 int i=0;
 int tmp;
 int best;
 couleur = pli[0]/100;

 while(i<4)
   { if (pli[i]==-100)
     {points[i]=-1;}
     else
     {
   tmp = pli[i]/100;
     if ((tmp != couleur) && (tmp != atout)) /* si la carte jouée n'est ni la couleur demandée ni de l'atout */
       {
        points[i]= 0;
       }
     else
       {
   	  if ((tmp == couleur) && (couleur != atout)) /* si la carte jouée est de la couleur demandée sauf de l'atout */
          {
            tmp = pli[i] % 100;
            switch (tmp)
              {    case 0 : points[i] = 8; /*AS*/
                   			break;
     				 	 case 1 : points[i] = 6; /*Roi*/
                  			 break;
        				 case 2 : points[i] = 5; /*Dame*/
                  			 break;
       				 case 3 : points[i] = 4; /*Valet*/
                  			 break;
        				 case 4 : points[i] = 7; /*10*/
                  			 break;
      			    case 5 : points[i] = 3; /*9*/
                  			 break;
       			    case 6 : points[i] = 2; /*8*/
                   			 break;
         			 case 7 : points[i] = 1; /*7*/
                  			 break;

     			  }
         }
      else     /* si la carte jouée est de l'atout */
        {  tmp = pli[i] % 100;
        		switch (tmp)
      			{   case 0 : points[i] = 16; /*AS*/
                           break;
                   case 1 : points[i] = 14; /*Roi*/
        			            break;
        				 case 2 : points[i] = 13; /*Dame*/
                   			break;
       				 case 3 : points[i] = 18; /*Valet*/
                   			break;
       			 	 case 4 : points[i] = 15; /*10*/
                   			break;
      			    case 5 : points[i] = 17; /*9*/
                  		   break;
      			    case 6 : points[i] = 12; /*8*/
                   			break;
      			    case 7 : points[i] = 11; /*7*/
                   			break;
              }
        }
      }
      }
 i++;}
 tmp = 0;
 best = points[0];
 i=1;
 while (i<4)
 {if (points[i] > best)
    {best = points[i];
    tmp = i;}
  i++;
 }
 return tmp;/*le vainqueur est tmp*/
}

/*******************************************/
/* programme principal                     */
/*******************************************/
void main()
{
int  pli[4];
int  p0[8];
int  p1[8];
int  p2[8];
int  p3[8];
int  atout;
int choix;
int joueur;
int carte;
int t;
int i;
int j;
int no;
int tour;
int equipe;
int resultathumain=0;
int resultatcpu=0;
int pri;
time_t * k = NULL;
time_t z;


z=time(k);
srand( z );
/*srand(0); */
init(p0,p1,p2,p3);

printf("voici vos cartes\n\n");
t=0;

while (t<8)
{
affiche(p0[t]);
t++;
}
/*   Ici il faudrait implementer les encheres */

printf("\n Quel est l'atout?\n\n"
             "1) Coeur\n"
             "2) Carreaux\n"
             "3) Trefle\n"
             "4) Pique\n"

             "Entrez votre choix :");
      scanf("%d",&choix);
      fflush(stdin);
      switch (choix)
      {
      	 case 1 : atout=0;
                   break;
        	 case 2 : atout=1;
                   break;
       	 case 3 : atout=2;
                   break;
        	 case 4 : atout=3;
                   break;

     }
     printf("L'atout est ");
     switch (atout)
      {   case 0 : printf("Coeur.....\n");
      				 break;
      	 case 1 : printf("Carreaux..\n");
                   break;
        	 case 2 : printf("Trefle....\n");
                   break;
       	 case 3 : printf("Pique.....\n");
                   break;

     }


joueur = 0;    /* à modifier selon les encheres*/
pri = 0;



				/*********************************************************************/
				/*  tout est initialise                                              */
				/*********************************************************************/
 tour=0;
 while(tour < 8)
 { t=0;
   while(t<4)     /* initialisation du pli */
     {  pli[t]=-100;
       t++;
      }

 switch(joueur)
 {case 0 :

 humain(p0,pli,atout,0);
 joue(p1,pli, atout,1,pri+1);
 joue(p2,pli, atout,2,pri);
 joue(p3,pli, atout,3,pri+1);
 break;

 case 1 :

 joue(p1,pli, atout,0,pri+1);
 joue(p2,pli, atout,1,pri);
 joue(p3,pli, atout,2,pri+1);
 humain(p0,pli,atout,3);
 break;

  case 2 :

 joue(p2,pli, atout,0,pri);
 joue(p3,pli, atout,1,pri+1);
 humain(p0,pli,atout,2);
 joue(p1,pli, atout,3,pri+1);
 break;

 case 3 :

 joue(p3,pli, atout,0,pri+1);
 humain(p0,pli,atout,1);
 joue(p1,pli, atout,2,pri+1);
 joue(p2,pli,atout,3,pri);
 break;

 }



     
 t=0;
while (t<4)
{affiche(pli[t]);
t++;
}



 t = vainqueur(pli,atout);
 joueur = (t+joueur)%4;

 printf("le vainqueur %d\n",joueur);
 equipe = ( ( ( joueur % 2) + 1 ) *10);    /* l'equipe 10 est l'equipe contenant humain(0) + cpu (2) */

	t=0;                                   /* l'equipe 20 est l'equipe contenant cpu(1) + cpu(3) */
	while(t<4)
	{tab [pli[t]/100][pli[t]%100] = equipe;
	t++;
	}
   if(tour==7)                /* gestion du 10 de der */
   {
      if (equipe == 10)
      {resultathumain =10; }
      else
      {resultatcpu = 10;   }
   }


tour++;
   }



i=0;
j=0;
while(i<4)
{   while(j<8)
    { if(tab[i][j]==10)
      {resultathumain=resultathumain + valeur(100*i+j,atout);}
      else
      {resultatcpu=resultatcpu + valeur(100*i+j,atout);}
      j++;
    }
i++;
j=0;
}
printf("vous avez fait %d points et le cpu %d points \n",resultathumain,resultatcpu);



}