[VC++] POKER

// Poker 
#include <stdlib.h> //pour rand()
#include <time.h> // pour l'initialisation de la randomisation
#include <econio.h>
#include <stdio.h>
#include <iostream.h>

void brasser (int [][ 13 ]); // peut servir à un jeu de 32 cartes
void distribuer( int[][ 13 ] , int , int , int [][ 5 ] );// peut reservir
void afficher( int [][ 5 ]); // affiche le jeu du joueur
void afficherlefinal ( int [][ 5 ] , int [][ 5 ] ); // les 2 mains
void changer( int [][ 13 ] , int [][ 5 ] , int , int , int * ); // voir la fct + bas
void trier( int [][ 5 ] , const int ); // tri bulle d'une liste de dimension variable
void resultat ( int ); // affiche brelan , paire , que dalle...
int analyser( int [][ 5 ] , int * );// renvoie la qualite du jeu
int decider ( int , int , int * , int * ); // renvoie le nb de cartes à changer

const char *couleur[ 4 ] = { "\3" , "\4" , "\5" , "\6" }; // coeur & co
const char *face[ 13 ] = { "Deux" , "Trois" , "Quatre" ,
		"Cinq" , "Six" , "Sept" , "Huit" , "Neuf" , "Dix" , "Valet" ,
		"Dame" , "Roi" , "As" }; 

int main()
{
	int tempjoueur[ 4 ] = { 0 };// contient les indices des bonnes cartes
	int temppc[ 4 ] = { 0 };// qui font partie d'une paire , d'un brelan...
	int maindupc[ 2 ][ 5 ] = { 0 }; //cartes piochées
	int maindujoueur[ 2 ][ 5 ] = { 0 };
	int victoirespc = 0; // sans commentaires. On peut faire avec de l'argent
	int victoiresjoueur = 0; // cf version 1.1
	int qualitedujeudupc; // indice de la qualité de la main
	int qualitedujeudujoueur;// voir plus loin
	int cartesjoueurachanger; // en fait nombre de cartes à changer
	int cartespcachanger;
	int numeroscarte[ 4 ] = { 0 }; // contiendra les numeros des cartes à changer
	int temp = 0; //contiendra les indices de "bonnes" cartes (pas toutes)
	int temp2 = 0; // (qui font partie d'une combinaison)
	srand(time(0)); // initialise le randomizer
	
	textbackground(GREEN); // zolie présentation
	for ( int pos = 0 ; pos <= 78 ; pos++ )
		printf( "*" );
	printf( "\n" );
	for(int posi = 0 ; posi < 6 ; posi++ )
	{
		printf( "*" );
		for ( pos = 1 ; pos <= 77 ; pos++ )
			printf( " " );
		printf( "*\n" );
	}
	for ( pos = 0 ; pos <= 78 ; pos++ )
		printf( "*" );
	printf( "\n" );

	gotoxy( 20 , 3 );
	textbackground( RED );
	printf( "POKER version 1.3 programmed by GoldenEye" );
	textbackground( GREEN ); // ne pas oublier de remettre les caractères 
	gotoxy( 29 , 5 ); // suivants en vert
	textbackground( BLUE );
	printf( "August & September 2001" );
	textbackground( GREEN );
	gotoxy( 1 , 9 );
	textbackground( WHITE );
	printf( "Bonjour, vous avez 0 victoire(s).\n\n" );
	printf( "Moi, l'ordinateur, j'ai aussi 0 victoire(s).\n" );
	printf( "Appuyez sur une touche pour commencer !" );
	getch();
	clrscr();
	while ( ( victoirespc < 10 ) &&  ( victoiresjoueur < 10 ) ) // 10 victoires = gagné
	{
		qualitedujeudujoueur = 0;
		qualitedujeudupc = 0;
		int jeu[ 4 ][ 13 ] = { 0 }; // Ce sont les 52 cartes
		for ( int i = 0 ; i < 4 ; i++ ) 
		{
			for ( int j = 0 ; j < 13 ; j++ )
				jeu[ i ][ j ] = j + 1 + 13 * i; // on remplit le jeu de 1 à 52 
		}
		printf( "Voici votre pige :" );
		printf( "\n" );
	
		brasser( jeu ); // mélange le jeu (algorithme de brassage performant)
		distribuer( jeu , 1 , 5 , maindujoueur ); // conçoit les 2 mains 
		distribuer( jeu , 6 , 10 , maindupc ); // 6 -> 10 signifie qu'on va chercher
		trier( maindujoueur , 5 );
		afficher( maindujoueur ); // les cartes 6 à 10 dans le jeu brassé 
		printf( "Voyant votre jeu, combien de cartes voulez vous changer ?" );
		cin >> cartesjoueurachanger;
		while ( ( cartesjoueurachanger < 0 ) || ( cartesjoueurachanger > 4 ) )
		{
			printf( "\nIgnoble tricheur !!!\n" );
			printf( "Donnez un chiffre correct bon sang !\n" );
			cin >> cartesjoueurachanger;// petit futé (bis)
		}
		for ( int h = 1 ; h <= cartesjoueurachanger ; h++ )
		{ // remplit le tableau des n° à changer
			printf( "Num\202ro de la carte \205 changer ( entre 1 et 5 ) " );
			cin >> numeroscarte[ h - 1 ];// attention au décalage de 1
			while ( ( numeroscarte[ h - 1 ] > 5 ) || ( numeroscarte[ h - 1 ] < 0 ) )
			{
				printf( "\nPas de blagues petit salaud !\n" );
				printf( "Num\202ro de la carte \205 changer ( entre 1 et 5 )" );
				cin >> numeroscarte[ h - 1 ]; // numero de carte entre 1 et 5
			}// Ne vérifie pas que le joueur entre des numéros à chaque fois différents
		}// fin du for
		changer( jeu , maindujoueur , cartesjoueurachanger , 10 , numeroscarte ); 
		trier( maindupc , 5 );// tri avant changement de carte(s) du PC
		trier( maindujoueur , 5 );// tri après les changements éventuels du joueur.
		qualitedujeudupc = analyser( maindupc , temppc ); // avant changement de carte
		qualitedujeudujoueur = analyser( maindujoueur , tempjoueur );// après échanges
	    cartespcachanger = decider( qualitedujeudupc , cartespcachanger , numeroscarte , temppc );
		printf( "Mmmhh, moi, le PC, je vais changer ...  %d carte(s).\n" , cartespcachanger);
		printf( "Le r\202sultat final est ... Appuyez sur une touche !" );
		getch();
		clrscr();
		changer ( jeu , maindupc , cartespcachanger , 10 + cartesjoueurachanger , numeroscarte );
		trier( maindupc , 5 );  // 5 est le nombre de cartes de la main
		qualitedujeudupc = analyser( maindupc , temppc );
		afficherlefinal( maindujoueur , maindupc );
		resultat( qualitedujeudujoueur ); 
		if ( qualitedujeudujoueur >= qualitedujeudupc )
		{
			victoiresjoueur++;
			textbackground( CYAN );
			printf( "Bravo, vous avez une meilleure main que la mienne.\n" );
		}
		else
		{
			victoirespc++; // lui aussi peut gagner...
			textbackground( MAGENTA );
			printf( "Ha ha ha, j'ai mieux jou\202 que vous cette fois ci !\n" );
		}
		textbackground( WHITE );
		printf( "Vous avez d\202sormais %d victoire(s).\n" , victoiresjoueur );
		printf( "Quant \205 moi , j'ai: %d succ\212s.\n" , victoirespc );
	   printf( "On continue \205 jouer ? ( 0 pour arr\210ter , 1 sinon )" );
		cin >> temp; // afficher le nombre de victoires de chaque camp
		clrscr();
		if ( temp == 0 )
			victoirespc = 10;
	} // fin du while
	if ( victoirespc > victoiresjoueur )// le perdant a 0 ou moins en francs
	{
		textbackground( RED );
		printf( "\nVOUS avez perdu car JE suis le Maitre du Poker !\n\n" ); //niqué
	}
	else
	{
		textbackground( BLUE );
		printf( "\nBravo , vous m'avez vaincu...\n\n" ); // pas niqué !!!
	}
	return 0;
}  // fin de main()

// début des fonctions dont les en-têtes sont au début du fichier source.

void brasser ( int wjeu[][ 13 ] ) // algorithme très performant sans report indéfini
{
	int permute1 , permute2 , temp;
	for( int  k = 0 ; k < 4 ; k++)
	{ // voir page 344
   		for( int l = 0 ; l < 13 ; l++)
		{
			permute1 = rand() % 4; 
			permute2 = rand() % 13;
			temp = wjeu[ k ][ l ];
			wjeu[ k ][ l ] =  wjeu[ permute1 ][ permute2 ];
			wjeu[ permute1 ][ permute2 ] = temp;
		}
	}
}

void distribuer ( int wjeu[][ 13 ] , int premierecarte , int dernierecarte , int main[][ 5 ] )
{	
	int q; // principe du moindre privilège: q et r n'ont pas d'existence légale hors
	int r; // de la fonction
	for ( int m = premierecarte ; m <= dernierecarte ; m++) // algo général aux jeux
	{					// de cartes 
		q = 0;  // algorithme performant de distribution.
		r = 0;
		while( wjeu[ q ][ r ] != m )
		{
			if ( q == 3 ) // cherche la carte 
			{
				q = 0;
				r++;
			}
			else
				q++;
		}
		main[ 0 ][ m - premierecarte ] = r; // faire gaffe au décalage de 1
		main[ 1 ][ m - premierecarte ] = q;	
	}			
}

void afficher( int main[][ 5 ] )
{
	for ( int k = 0 ; k < 5 ; k++ ) // affiche la main du joueur
	{
		gotoxy( 1 , 2 + 2 * k );
		textbackground( YELLOW );
		printf( face[ main[ 0 ][ k ] ] ); // (main+k)/100 = r de la fonction distribuer 
		    // (valeur de la carte)
		textbackground( WHITE );
		gotoxy( 8 , 2 + 2 * k ); 
		printf( " de " );
		gotoxy( 15 ,  2 + 2*k );
		if ( ( main[ 1 ][ k ] == 0 ) || ( main[ 1 ][ k ] == 1 ) )
		    textbackground( RED );// si c'est coeur ou carreau
		else
			textbackground( BLUE ); // si c'est pique ou trêfle
		printf( couleur[ main[ 1 ][ k ] ] );
		gotoxy( 30 , 2 + 2 * k );
		textbackground( WHITE );
		printf ( "( %d )" , k + 1 );
		printf( "\n\n" );
	}
}

void afficherlefinal ( int main1[][ 5 ] , int main2[][ 5 ] )
{
	printf( "  VOTRE MAIN                            MAIN DU PC\n\n" );
 	for ( int k = 0 ; k < 5 ; k++)
	{
		gotoxy( 0 , 2 + 2 * k);
		textbackground( YELLOW );
		printf( face[ main1[ 0 ][ k ] ] );
		textbackground( WHITE );
		gotoxy( 7 , 2 + 2 * k);
		printf( " de " );
		gotoxy( 14 , 2 + 2 * k );
		if ( ( main1[ 1 ][ k ] == 0 ) || ( main1[ 1 ][ k ] == 1 ) )
			textbackground( RED );
		else
			textbackground( BLUE );
		printf( couleur[ main1[ 1 ][ k ] ] ); // (main+k)%10 = q de la fonction distribuer
		textbackground( YELLOW );
		gotoxy( 37  , 2 + 2 * k );
		printf( face[ main2[ 0 ][ k ] ] ); // (main+k)/100 = r de la fonction distribuer
			     // (valeur de la carte)
		textbackground( WHITE );
		gotoxy( 44 , 2 + 2 * k );
		printf( " de " );
		gotoxy( 51 , 2 + 2 * k );
		if ( ( main2[ 1 ][ k ] == 0 ) || ( main2[ 1 ][ k ] == 1 ) )
			textbackground( RED );
		else
			textbackground( BLUE );
		printf( couleur[ main2[ 1 ][ k ] ] ); // (main+k)%10 = q de la fonction distribuer
			     // (la couleur)
		textbackground( WHITE );
		printf( "\n\n" ); // de manière propre
	}
}

void changer( int wjeu[][ 13 ] , int main[][ 5 ] , int nombre , int depart , int *numero )
{
	int q;
	int r;
	for ( int i = 1 ; i <= nombre ; i++)
	{
		q = 0;
		r = 0;
		while ( wjeu[ q ][ r ] != i + depart )
		{
			if ( q == 3 )
			{
				q = 0;
				r++;
			}
			else
				q++;
		} 
		main[ 0 ][ *(numero + i - 1) - 1 ] = r; // la valeur de la carte
		main[ 1 ][ *(numero + i - 1) - 1 ] = q; // la couleur
	}
}

void trier ( int tableau[][ 5 ] , const int taille)
{
	int temp; // tri bulle de la main du joueur ou du pc -> peut mieux faire
	for ( int passage = 0 ; passage < taille - 1 ; passage++)
		for ( int j = 0 ; j < taille - 1 ; j++)
			if ( tableau[ 0 ][ j ] > tableau[ 0 ][ j + 1] )
			{
				temp = tableau[ 0 ][ j ];
			    tableau[ 0 ][ j ] = tableau[ 0 ][ j + 1 ];
				tableau[ 0 ][ j + 1 ] = temp;
				temp = tableau[ 1 ][ j ];
				tableau[ 1 ][ j ] = tableau[ 1 ][ j + 1 ];
				tableau[ 1 ][ j + 1 ] = temp;
			}
}

int analyser( int main[][ 5 ] , int *temp )
{							// renvoie la qualité du jeu
	int qualite = 0;
	int paire = 0;
	int tp = 0;
	for (int i = 0 ; i < 4 ; i++)
		if ( main[ 0 ][ i ] == main[ 0 ][ i + 1 ])
		{
			paire++;
			temp[ tp ] = i + 1; // numéro de la carte
			tp++;
		}
	switch ( paire )
	{
	case 0:
		qualite += main[ 0 ][ 4 ]; // rien du tout
		break;
	case 1:
		qualite += 100+main[ 0 ][ temp[ 0 ] ]; // paire
		break;
	case 2:
		if( main[ 0 ][ temp[ 0 ] ] != main[ 0 ][ temp[ 1 ] ] )
			qualite += 200 + main[ 0 ][ temp[ 0 ] ] + main[ 0 ][temp[ 1 ] ];
		else  // double paire
			qualite += 300 + main[ 0 ][ temp[ 0 ] ]; // brelan
		break;
	case 3:
		if ( main[ 0 ][temp[ 0 ] ] != main[ 0 ][ temp[ 2 ] ]) 
			qualite += 400 + main[ 0 ][ temp[ 0 ] ] + main[ 0 ][temp[ 2 ]]; // full
		else
			qualite += 500 + main[ 0 ][ temp[ 0 ]]; // carré
		break;
	default:
		break;
	}
	if ( ( main[ 0 ][ 0 ] == main[ 0 ][ 1 ] - 1 ) && 
		 ( main[ 0 ][ 1 ] == main[ 0 ][ 2 ] - 1 ) &&
		 ( main[ 0 ][ 2 ] == main[ 0 ][ 3 ] - 1 ) &&
		 ( main[ 0 ][ 3 ] == main[ 0 ][ 4 ] - 1 ) &&
		 ( main[ 1 ][ 0 ] == main[ 1 ][ 1 ] ) &&
		 ( main[ 1 ][ 1 ] == main[ 1 ][ 2 ] ) && 
		 ( main[ 1 ][ 2 ] == main[ 1 ][ 3 ] ) &&
		 ( main[ 1 ][ 3 ] == main[ 1 ][ 4 ] ) )
		 qualite += 600; //suite royale !
	return qualite;
}

int decider( int qualitedujeudupc , int cartespcachanger , int *numeroscarte , int *temppc )
{ // renvoie le nombre de cartes à changer pour le PC
	if ( qualitedujeudupc < 100 ) // t'as que dalle coco
		{
			cartespcachanger = 1 + rand() % 4;// algorithme peu performant 
			for ( int compteur = 0 ; compteur < cartespcachanger  ; compteur++ ) 	
			{	// report indéfini...
				numeroscarte[ compteur ] = 1 + rand() % 5;
			}// on peut avoir 2 cartes identiques , le PC changera 2 fois
		}
		else if ( qualitedujeudupc < 200 ) 
		{	// la carte ce qui apparaîtra comme étant un seul changement
			cartespcachanger = 3; //  paire -> 3 cartes à changer
			numeroscarte[ 0 ] = 1 + rand() % 5;
			numeroscarte[ 1 ] = 1 + rand() % 5; 
			numeroscarte[ 2 ] = 1 + rand() % 5;
			while ( numeroscarte[ 0 ] == numeroscarte[ 1 ] || 
				    numeroscarte[ 0 ] == numeroscarte[ 2 ] ||
				    numeroscarte[ 1 ] == numeroscarte[ 2 ] ||
				    numeroscarte[ 0 ] == temppc[ 0 ] 	   ||
				    numeroscarte[ 0 ] == temppc[ 0 ] + 1   ||
				    numeroscarte[ 1 ] == temppc[ 0 ]       ||
				    numeroscarte[ 1 ] == temppc[ 0 ] + 1   ||
				    numeroscarte[ 2 ] == temppc[ 0 ]       ||
				    numeroscarte[ 2 ] == temppc[ 0 ] + 1   )
			{
				numeroscarte[ 0 ] = 1 + rand() % 5;
				numeroscarte[ 1 ] = 1 + rand() % 5; // ne pas changer une bonne carte !
				numeroscarte[ 2 ] = 1 + rand() % 5;
			}
		}
		else if ( qualitedujeudupc < 300 )
		{
			cartespcachanger = 1; // double paire -> 1 carte à changer
			numeroscarte[ 0 ] = 1 + rand() % 5;
			while ( numeroscarte[ 0 ] == temppc[ 0 ]     ||
					numeroscarte[ 0 ] == temppc[ 0 ] + 1 ||
					numeroscarte[ 0 ] == temppc[ 1 ]     ||
					numeroscarte[ 0 ] == temppc[ 1 ] + 1 )
			numeroscarte[ 0 ] = 1 + rand() % 5; // ne pas changer une bonne carte !!!
		}
		else if ( qualitedujeudupc < 400 )
		{
			cartespcachanger = 2;
			numeroscarte[ 0 ] = 1 + rand() % 5;
			numeroscarte[ 1 ] = 1 + rand() % 5;
			while ( numeroscarte[ 0 ] == numeroscarte[ 1 ] ||
				    numeroscarte[ 0 ] == temppc[ 0 ]       ||
					numeroscarte[ 0 ] == temppc[ 0 ] + 1   ||
					numeroscarte[ 0 ] == temppc[ 0 ] + 2   ||
					numeroscarte[ 1 ] == temppc[ 0 ]       ||
					numeroscarte[ 1 ] == temppc[ 0 ] + 1   ||
					numeroscarte[ 1 ] == temppc[ 0 ] + 2   )
			{
				numeroscarte[ 0 ] = 1 + rand() % 5;
			    numeroscarte[ 1 ] = 1 + rand() % 5;
			}
		}
		else if ( qualitedujeudupc < 500 )
			cartespcachanger = 0; // full
		else if ( qualitedujeudupc < 600 )  // carré
		{
			cartespcachanger = 1;
			numeroscarte[ 0 ] = 1 + rand() % 5;
			while ( numeroscarte[ 0 ] == temppc[ 0 ]     ||
					numeroscarte[ 0 ] == temppc[ 0 ] + 1 ||
					numeroscarte[ 0 ] == temppc[ 0 ] + 2 ||
					numeroscarte[ 0 ] == temppc[ 0 ] + 3 )
			numeroscarte[ 0 ] = 1 + rand() % 5; // ne pas changer une bonne carte !!!	
		}
		else if ( qualitedujeudupc < 700 )
			cartespcachanger = 0;
		return cartespcachanger;
}

void resultat ( int qualite ) // Ce que le joueur possède dans sa main
{
	if ( qualite < 100 )
		printf( "Vous n'avez malheureusement rien de bon... \n" );
	else if ( qualite < 200 )
		printf( " C'est correct , vous avez une paire ( %s ) \n" , face[ qualite % 100 ] ); 
	else if (qualite < 300 )
		printf( "Pas mal , vous obtenez une double paire.\n" );
	else if ( qualite < 400 )
		printf( "Bien , vous tirez un brelan ( %s )\n" , face[ qualite % 100 ] );
	else if ( qualite < 500 )
		printf( "Coup de chance , c'est un flush !\n" );
	else if (qualite < 600 )
		printf( "Vous etes b\202ni(e) des dieux , un carr\202 !! ( %s )\n" , face[ qualite % 100 ] );
	else if (qualite < 700 )
		printf( "Whazaaa , une suite royale !!!\n" );
}

// Voilà c'est (enfin) fini. Tout est en C mode console (les caractères accentués sont les \2**)
// Merci à Eric Tetz pour econio.h