path: root/Bachelor/Prog1/Prakt5/prg1p5_4/main.cpp

// Programmieren 1, Praktikum 5, Aufgabe 4
// Sven Eisenhauer
// 10.01.2005
//
// file: main.cpp
//
// purpose: Shuffle a standard deck of 52 cards, deal a poker game and analyse the cards of the player
//

#include <iostream>

using std::cin;
using std::cout;
using std::endl;
using std::left;
using std::right;


#include <iomanip>

using std::setprecision;
using std::setw;

// contains function prototypes for functions srand and rand
#include <cstdlib>
#include <ctime>

const int maxColumns=13;
const int maxRows=4;
const int maxCards=52;
const int cards=7;
const int maxResults=10;
const int nrGames=1000000;

struct hand {
	const char *farbe;
	const char *wert;
};


// prototypes
void shuffle( int [][ maxColumns ] );
void deal( const int [][ maxColumns ], const char *[], const char *[], hand[] );
void printHand(const hand []);
void analyseCards(const hand[], const char *[], const char *[],int[],const char *[]);
void printResults(const int[],const char *[]);

int onePair(const hand[], const char *[]);
int twoPairs(const hand[], const char *[]);
int threeOfAKind(const hand[], const char *[]);
int straight(const hand[], const char *[]);
int flush(const hand[], const char *[]);
int fullHouse(const hand[], const char *[]);
int fourOfAKind(const hand[], const char *[]);
int straightFlush(const hand[], const char *[], const char *[]);
int royalFlush(const hand[], const char *[], const char *[]);

int main()
{
   hand blatt[cards];

   int erg[maxResults]={0};

   const char *results[maxResults] =
   { "Nothing","One Pair","Two Pairs","Three of a kind",
     "Straight","Flush","Full house","Four of a kind",
	 "Straight Flush","Royal Flush" };

   // initialize suit array
   const char *suit[ 4 ] =  
      { "Hearts", "Diamonds", "Clubs", "Spades" };
   
   // initialize face array
   const char *face[ 13 ] = 
      { "Ace", "Deuce", "Three", "Four",
        "Five", "Six", "Seven", "Eight",
        "Nine", "Ten", "Jack", "Queen", "King" };

   // initialize deck array
   int deck[ maxRows ][ maxColumns ] = 
   { 
	   { 1,2,3,4,5,6,7,8,9,10,11,12,13 },
	   { 14,15,16,17,18,19,20,21,22,23,24,25,26 },
	   { 27,28,29,30,31,32,33,34,35,36,37,38,39 },
	   { 40,41,42,43,44,45,46,47,48,49,50,51,52 }
   };

   srand( time( 0 ) );        // seed random number generator

   for (int n=1;n<=nrGames;n++)
   {
	   shuffle( deck );
	   deal( deck, face, suit, blatt );
	   //printHand(blatt);
	   analyseCards(blatt,face,suit,erg,results);
   }
   printResults(erg,results);

   return 0;  // indicates successful termination

} // end main

void printHand(const hand blatt[])
{   
	cout << endl << endl << "Player's cards:" << endl;
	for (int i=0;i<cards;i++)
	   cout << blatt[i].wert << " of " << blatt[i].farbe << endl;
}// end function print hand

void printResults(const int erg[], const char *results[])
{
	cout << endl;
	for (int i=0;i<maxResults;i++)
	{
		cout << results[i] << ": " << erg[i] << endl;
	}
}

void analyseCards(const hand blatt[],const char *wFace[],
           const char *wSuit[],int erg[], const char *results[])
{
	int hasOnePair=0;
    int hasTwoPairs=0;
    int hasThreeOfAKind=0;
	int hasFullHouse=0;
	int hasFourOfAk=0;
	int hasFlush=0;
	int hasStraight=0;
	int hasStraightFlush=0;
	int hasRoyalFlush=0;

    hasOnePair=onePair(blatt,wFace);
	hasTwoPairs=twoPairs(blatt,wFace);
	hasThreeOfAKind=threeOfAKind(blatt,wFace);
    hasFullHouse=fullHouse(blatt,wFace);
	hasFourOfAk=fourOfAKind(blatt,wFace);

    if (1 == hasOnePair)
    {
		erg[1]++;
	}
	   
	if (1 == hasTwoPairs)
	{
		erg[2]++;
	}
	if (1 == hasThreeOfAKind)
	{
		if(1==hasFullHouse)
		{
			 erg[6]++;
		}
		else
		{
			 erg[3]++;
		}
	}
	   		   
	if (1==hasFourOfAk)
		erg[7]++;

		hasFlush=flush(blatt,wSuit);
		hasStraight=straight(blatt,wFace);
	    hasStraightFlush=straightFlush(blatt,wFace,wSuit);
	    hasRoyalFlush=royalFlush(blatt,wFace,wSuit);
		if(1==hasFlush)
		{			
			if(1==hasStraight)
			{

				if(1==hasStraightFlush)
				{
					if(1==hasRoyalFlush)
					{
						erg[9]++;
					}
					else
					{
						erg[8]++;
					}
				}
			}
			else
			{
				erg[5]++;
			}
		}
		else
		{
			if(1==hasStraight)
			{
				erg[4]++;
			}
		}

	if (hasOnePair==0 && hasTwoPairs==0 && hasThreeOfAKind==0 && hasFullHouse==0 && hasFourOfAk==0 && hasFlush==0 && hasStraight==0 && hasStraightFlush==0 && hasRoyalFlush==0)
		erg[0]++;
}


// shuffle cards in deck
void shuffle( int wDeck[][ 13 ] )
{
	int temp=0;
	int randRow,
		randCol;

	for (int column=0;column<maxColumns;column++) {
		for (int row=0;row<maxRows;row++) {
			randCol=rand()%maxColumns;
			randRow=rand()%maxRows;
			temp=wDeck[row][column];
			wDeck[row][column]=wDeck[randRow][randCol];
			wDeck[randRow][randCol]=temp;
		}
	}
} // end function shuffle

// deal cards in deck
void deal( const int wDeck[][ 13 ], const char *wFace[],
           const char *wSuit[], hand karten[cards] )
{
	enum found {FALSE,TRUE};
	int row,column;
	found cardFound=FALSE;
    // give first 5 cards
	for ( int card = 1; card <= cards; card++ ) {
		cardFound=FALSE;
		row=0;
		while ((row<maxRows)&&cardFound==FALSE)
		{
			column=0;
			while((column<maxColumns)&&cardFound==FALSE)
			{
                // if slot contains current card, display card
                if ( wDeck[ row ][ column ] == card ) {
					/* cout << setw( 5 ) << right << wFace[ column ] 
					   << " of " << setw( 8 ) << left 
					   << wSuit[ row ]
					   << ( card % 2 == 0 ? '\n' : '\t' );
					*/   
				    karten[card-1].farbe=wSuit[row];
				    karten[card-1].wert=wFace[column];
					cardFound=TRUE;
				}
				column++;

            } // end while
			row++;
		 }
	}
} // end function deal

int onePair(const hand mycards[], const char *myFace[])
{
    int faces[13]={0};
	int pairCounter=0;
	int pair=0;
	int n;

	for (int i=0;i<cards;i++)
	{
		for (n=0;n<13;n++)
			if (mycards[i].wert == myFace[n])
				faces[n]++;
	}
    for (n=0;n<13;n++)
	{
		if (faces[n]==2)
			pairCounter++;
	}
	if (pairCounter==1)
		pair=1;
	return pair;
}

int twoPairs(const hand mycards[], const char *myFace[])
{
	int faces[13]={0};
	int twoPairs=0;
	int pairCounter=0;
	int n;

	for (int i=0;i<cards;i++)
	{
		for (n=0;n<13;n++)
			if (mycards[i].wert == myFace[n])
				faces[n]++;
	}
    for (n=0;n<13;n++)
	{
		if (faces[n]==2)
			pairCounter++;
	}
	if (pairCounter==2)
		twoPairs=1;

	return twoPairs;
}
int threeOfAKind(const hand mycards[], const char *myFace[])
{
    int faces[13]={0};
	int toak=0;
	int n;

	for (int i=0;i<cards;i++)
	{
		for (n=0;n<13;n++)
			if (mycards[i].wert == myFace[n])
				faces[n]++;
	}
    for (n=0;n<13;n++)
	{
		if (faces[n]==3)
			toak=1;
	}
	return toak;
}
int straight(const hand mycards[], const char *myFace[])
{
	int str=0;
	int n;
	int faces[13]={0};

	for (int i=0;i<cards;i++)
	{
		for (n=0;n<13;n++)
			if (mycards[i].wert == myFace[n])
				faces[n]++;
	}
    for (n=0;n<13;n++)
	{
		if (faces[n]==1 && faces[n+1]==1 && faces[n+2]==1 && faces[n+3]==1 && faces[n+4]==1)
			str=1;
	}
	return str;
}
int flush(const hand mycards[], const char *mySuit[])
{
    int suits[4]={0};
	int flush=0;
	int n;
	const int countingCards=5;

	for (int i=0;i<cards;i++)
	{
		for (n=0;n<4;n++)
			if (mycards[i].farbe == mySuit[n])
				suits[n]++;
	}
    for (n=0;n<4;n++)
	{
		if (suits[n]==countingCards)
			flush=1;
	}
	return flush;
}
int fullHouse(const hand mycards[], const char *myFace[])
{
	int full=0;
	if(1==threeOfAKind(mycards,myFace)&&1==twoPairs(mycards,myFace))
	{
		full=1;
		//cout << endl << "Full House" <<endl;
	}
	return full;
}
int fourOfAKind(const hand mycards[], const char *myFace[])
{
    int faces[13]={0};
	int foak=0;
	int n;

	for (int i=0;i<cards;i++)
	{
		for (n=0;n<13;n++)
			if (mycards[i].wert == myFace[n])
				faces[n]++;
	}
    for (n=0;n<13;n++)
	{
		if (faces[n]==4)
		{
			foak=1;
		}
	}

	return foak;
}
int straightFlush(const hand mycards[], const char *myFace[], const char *mySuit[])
{
	int strFlu=0;
	if (1==straight(mycards,myFace) && 1==flush(mycards,mySuit))
	{
		strFlu=1;
		//printHand(mycards);
	}
	return strFlu;
}
int royalFlush(const hand mycards[], const char *myFace[], const char *mySuit[])
{
	int roy1=0;
	int roy2=0;
	int roy=0;
	int i,n;
	int faces[13]={0};
	int suits[4]={0};
	const int countingCards=5;

	for (i=0;i<cards;i++)
	{
		for (n=0;n<13;n++)
			if (mycards[i].wert == myFace[n])
				faces[n]++;
	}

	if (faces[0]==1 && faces[9]==1 && faces[10]==1 && faces[11]==1 && faces[12]==1)
			roy1=1;


	for (i=0;i<cards;i++)
	{
		for (n=0;n<4;n++)
			if (mycards[i].farbe == mySuit[n])
				suits[n]++;
	}
    for (n=0;n<4;n++)
	{
		if (suits[n]==countingCards)
			roy2=1;
	}
	if (roy1==1 && roy2==1)
	{
		//printHand(mycards);
		roy=1;
	}
	return roy;
}