//! Video Poker in ZScript
//! Version 0.8
//! 14th September, 2020 

namespace videopoker
{
	//User Interface
	const int VPUI_FONT			= 0; //General UI font and colour. 
	const int VPUI_HOLD_COLOUR		= 0x01; //Whitetru
	const int VPUI_HOLD_BG_COLOUR		= 0; //Red, box behind 'HOLD' text. 

	//Felt
	const int VPUI_BACKGROUND_COLOUR = 0x0F; //Should be green.
	const int VPUI_FELT_WIDTH = 250; 
	const int VPUI_FELT_HEIGHT = 170;
	const int VPUI_FELT_X = 4; 
	const int VPUI_FELT_Y = 4; 
	const int VPUI_FELT_SCALE = 1;

	//Backdrop behind felt. 
	const int VPUI_COLOUR_BLACK = 0x0F;
	const int VPUI_BLACK_BG_SCALE = 1; 
	const int VPUI_BLACK_BG_X = 0;
	const int VPUI_BLACK_BG_Y = 0;
	const int VPUI_BLACK_BG_WIDTH = 255;
	const int VPUI_BLACK_BG_HEIGHT = 175;

	//Card Dimensions and Properties
	const int VP_CARD_HOLD_SPACING = 3; //Space between card bottom and 'HOLD' indicator. 

	const int VP_CARD_LAYER = 3; //Layer for drawing card objects to the screen.
	const int VP_CARD_WIDTH = 40;
	const int VP_CARD_HEIGHT = 60;
	const int VP_CARD_SPACING = 8; //Space between cards. 
	const int VP_CARD_COLOUR = 0x01; //White
	const int VP_CARD_SHADOW = 0x0F; //Black
	const int VP_CARD_OPACITY = 128; //Opaque
	const int VP_CARD_SHADOW_OPACITY = 64; //Trans

	const int VP_CARD_BASE_X = 10;
	const int VP_CARD_BASE_Y = 20; 

	const int VP_CARD_SHADOW_Y_OFFSET = 5;
	const int VP_CARD_SHADOW_X_OFFSET = 3;
	const int VP_CARD_SCALE = 1;

	//Card Display (Text)
		//Display of characters over the cards, for 2-10 and A-K-Q-J.
	const int VP_CARD_CHAR_X_OFFSET = 18;   //offset from card left/top edges
	const int VP_CARD_CHAR_Y_OFFSET = 24; 
	const int VP_CARD_CHAR_FONT = 1;  //font for glyphs
	const int VP_CARD_CHAR_BG_COLOUR = 0; //background colour of glyphs. Normally 0. 
	const int VP_CARD_CHAR_WIDTH = -1; //Glyph scale: This only works in 2.54+
	const int VP_CARD_CHAR_HEIGHT = -1;
	const int VP_CARD_CHAR_OPACITY = 128;

	//Hand Types
	const int HT_ROYAL = 9;
	const int HT_STRAIGHTFLUSH = 8;
	const int HT_FLUSH = 7;
	const int HT_STRAIGHT = 6;
	const int HT_QUADS = 5;
	const int HT_FULLHOUSE = 4;
	const int HT_TRIPS = 3;
	const int HT_TWOPAIR = 2;
	const int HT_ONEPAIR = 1;

	//Settings
	const int MAX_SHUFFLE_FRAMES = 600; 
		
	//String Display
	const int BETS_LAYER 		= 4; 
	const int BETS_X		= 5; //Where to display the number of bets on the UI. 
	const int BETS_Y		= -16;
	const int BETS_FONT		= 1;
	const int BETS_COLOUR		= 1;
	const int BETS_BG_COLOUR	= 0;
	const int BETS_FORMAT		= 0;

	//Suit Colours
	const int CARD_SUIT_HEARTS_COLOUR 	= 1; //Red
	const int CARD_SUIT_DIAMONDS_COLOUR 	= 1; //Blue
	const int CARD_SUIT_SPADES_COLOUR 	= 1; //Black
	const int CARD_SUIT_CLUBS_COLOUR 	= 1; //Green

	const int VP_MIN_PAIR = 11; //Jacks.
	const int VP_SFX_WIN = 31; 
	const int VP_SFX_LOSE = 0; 
	const int VP_SFX_HOLD = 0;
	const int VP_SFX_DRAWCARDS = 0;

	const int VP_SFX_BET = 0;

	ffc script VideoPoker
	{
		void run(int min_pair, int win_sfx, int lose_sfx, int holdcard_sfx, int draw_sfx, int counter, int bet_sfx){
			//c[5] used for fault timer
			
			if ( counter < 1 ) counter = CR_RUPEES; //Default. 
			//Defaults
			if ( min_pair < 1 ) min_pair = VP_MIN_PAIR;
			if ( lose_sfx < 1 ) lose_sfx = VP_SFX_LOSE;
			if ( win_sfx < 1 ) win_sfx = VP_SFX_WIN;
			if ( holdcard_sfx < 1 ) holdcard_sfx = VP_SFX_HOLD;
			if ( bet_sfx < 1 ) bet_sfx = VP_SFX_BET;
			
			min_pair = min_pair << 0; //Truncate for safety.
			
			//Numeric Values
			int cards[52]={1,2,3,4,5,6,7,8,9,10,11,12,13,
				1,2,3,4,5,6,7,8,9,10,11,12,13,
				1,2,3,4,5,6,7,8,9,10,11,12,13,
				1,2,3,4,5,6,7,8,9,10,11,12,13,};
			//Suits
			int suits[52]={	1,1,1,1,1,1,1,1,1,1,1,1,1,
					2,2,2,2,2,2,2,2,2,2,2,2,2,
					3,3,3,3,3,3,3,3,3,3,3,3,3,
					4,4,4,4,4,4,4,4,4,4,4,4,4 };
			//cards dealt.
			bool dealt[52];
			//five first cards, and five under them.
			int deal[10] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
			int counts[13]; //Pairs, pryles, quads.
			int c[255];
			
			bool held[5]; //The cards that will be held. 
			int hand[5]; //The final five chards after dealing.
			bool cardanims[5]; //holds what cards to 'flip'.
			int handbuf[5]; //Buffer to use for initial hand checking, to do preliminary display
			//if hand prior to discarding. 
			
			//X and Y of each of the five cards. 
			int cardpositions[5] = {
				
				VP_CARD_BASE_X,
				VP_CARD_BASE_X+((VP_CARD+WIDTH+VP_CARD_SPACING)*1), 
				VP_CARD_BASE_X+((VP_CARD+WIDTH+VP_CARD_SPACING)*2), 
				VP_CARD_BASE_X+((VP_CARD+WIDTH+VP_CARD_SPACING)*3), 
				VP_CARD_BASE_X+((VP_CARD+WIDTH+VP_CARD_SPACING)*4)};
				

			int s_hand_rank[40]; //String buffer for hand rank.
				
			int coins; //present number of coins.
			int betline = -1; //number of bets
			int s_coind[7]; //string to hold ItoA for coins
			int s_bets[2]; //String to hold ItoA for bets.
			
			bool draw; bool running;
			
			int handtype = doHandType(handbuf,cards,counts,min_pair); //Establish ther hand type. 
			//This needs a buffer so that we do not use 'hand'until we do a discard phase. 
			
			//We will check handtype again after doDraw(); 
			
			c[3] = getHandRankString(s_hand_rank, handtype); //Put the hand rank string into the buffer. 
				//c[3] holds the buffer pointer. 
				
			bool firstdeal = true; 	
				
			while ( firstdeal ) 
			{
				//Initial bet entry.
				
				drawVPUI(VPUI_FELT_X, VPUI_FELT_Y, VPUI_FELT_WIDTH, VPUI_FELT_HEIGHT, VPUI_BACKGROUND_COLOUR, VPUI_FELT_SCALE);  

				displayBetline(); //display the present number of bets.
				
				if ( KeyPress[KEY_1] ) { betline = 1; setBets(betline, s_bets); }
				if ( KeyPress[KEY_2] ) { betline = 2; setBets(betline, s_bets); }
				if ( KeyPress[KEY_3] ) { betline = 3; setBets(betline, s_bets); }
				if ( KeyPress[KEY_4] ) { betline = 4; setBets(betline, s_bets); }
				if ( KeyPress[KEY_5] ) { betline = 5; setBets(betline, s_bets); }
				
				//Press b for next hand.
				if ( KeyPress[KEY_B] ) { firstdeal = false; break; }
				
				Waitframe(); 
			}
			
			
			running = ( doBet(betline, counter, bet_sfx) && getCards(deck,hand) ); //Shuffle deck and load cards into hand[]. 
			
			while(running)
			{
				bool waiting = true; 
				//bool betting = true;
				
				
				//DIsplay the cards.
				
				//Display the current hand rank.
				
				//! Keys
				///	1-5 hold or unhold card 1 to 5
				///	b = set bet amount
				///	d = draw
				
				
				//!Display the UI
				drawVPUI(VPUI_FELT_X, VPUI_FELT_Y, VPUI_FELT_WIDTH, VPUI_FELT_HEIGHT, VPUI_BACKGROUND_COLOUR, VPUI_FELT_SCALE);
				
				//DISPLAY THE CARDS
				drawCards(cardpositions, hand, cards, suits); //Display the cards
				
				//DISPLAY WHICH ARE HELD
				drawHeld(cardpositions, held);
				
				//! This might be better as an if statement. 
				while(waiting)  //Waiting on input
				{
					drawVPUI(VPUI_FELT_X, VPUI_FELT_Y, VPUI_FELT_WIDTH, VPUI_FELT_HEIGHT, VPUI_BACKGROUND_COLOUR, VPUI_FELT_SCALE);
					
					displayBetline(); //display the present number of bets.
					drawCards(cardpositions, hand, cards, suits); //Display the cards. 
					
					//Allow player to hold cards.
					
					if ( KeyPress[KEY_1] ) { if ( holdcard_sfx ) Game->PlaySound(holdcard_sfx); held[0] = !held[0]; cardanims[0] = held[0]; }
					if ( KeyPress[KEY_2] ) { if ( holdcard_sfx ) Game->PlaySound(holdcard_sfx); held[1] = !held[1]; cardanims[1] = held[1]; }
					if ( KeyPress[KEY_3] ) { if ( holdcard_sfx ) Game->PlaySound(holdcard_sfx); held[2] = !held[2]; cardanims[2] = held[2]; }
					if ( KeyPress[KEY_4] ) { if ( holdcard_sfx ) Game->PlaySound(holdcard_sfx); held[3] = !held[3]; cardanims[3] = held[3]; }
					if ( KeyPress[KEY_5] ) { if ( holdcard_sfx ) Game->PlaySound(holdcard_sfx); held[4] = !held[4]; cardanims[4] = held[4]; }
					
					if ( KeyPress[KEY_D] ) { if ( draw_sfx) Game->PlaySound(draw_sfx); draw = true; waiting = false;  break; }
					
					drawHeld(cardpositions, held); //Draw 'HOLD'string at card locations. 
					
					Waitframe();
				}
				
				//Do the draw
				//!Update cards
				
				//future location of fancy animation.
				
				//Check what cards are held, and replace un-held cards. 
					
				if ( draw ) 
				{ 
					draw = false; 
					int display_timer = 300; 
					bool wait_nextgame;
					doDraw(deal, hand, held); //Update the hand.
					//Update hand evaluations. 
					handtype = doHandType(hand,cards,counts,min_pair);
					c[3] = getHandRankString(s_hand_rank, handtype);
					
					//!do animation
					//bool cardanims[5]; //holds what cards to 'flip'.
					//flip animated cards to reveal new cards
					//clear cardanims[]
					
					//Show payout.
					
					int pay = doOdds(betline); //Calculates the payout. 
					
					
					//Make sound. 
					
					if ( pay > 0 && win_sfx ) Game->PlaySound(win_sfx);
					if ( pay <= 0 && lose_sfx ) Game->PlaySound(lose_sfx);
					
					//Award the money.
					
					Game->DCounter[counter] += pay; //Might not want a counter for this.
					
					while( display_timer-- ) 
					{
						
						drawVPUI(VPUI_FELT_X, VPUI_FELT_Y, VPUI_FELT_WIDTH, VPUI_FELT_HEIGHT, VPUI_BACKGROUND_COLOUR, VPUI_FELT_SCALE);
					
						displayBetline(); //display the present number of bets.
						
						//Show strings.
						Waitframe();
					}
					
					//Pay out
					
					wait_nextgame = true; 
					
					//Show Next Game Options
					while ( wait_nextgame ) 
					{
						//Allow changing the bet amount, or exiting.
						
						if ( KeyPress[KEY_1] ) { betline = 1; setBets(betline, s_bets); }
						if ( KeyPress[KEY_2] ) { betline = 2; setBets(betline, s_bets); }
						if ( KeyPress[KEY_3] ) { betline = 3; setBets(betline, s_bets); }
						if ( KeyPress[KEY_4] ) { betline = 4; setBets(betline, s_bets); }
						if ( KeyPress[KEY_5] ) { betline = 5; setBets(betline, s_bets); }
						
						
						drawVPUI(VPUI_FELT_X, VPUI_FELT_Y, VPUI_FELT_WIDTH, VPUI_FELT_HEIGHT, VPUI_BACKGROUND_COLOUR, VPUI_FELT_SCALE);
						
						displayBetline(); //Show the present bet value. 
						
						//Press b for next hand.
						if ( KeyPress[KEY_B] ) { wait_nextgame = false; break; }		
						//Press key to begin new game.
						Waitframe(); 
					}	
					
					running = ( doBet(betline, counter, bet_sfx) && getCards(deck,hand) ); //Do next hand arrangement. 
					//!! Lack of short circuiting may cause a problem doing it this way. -Z
					//!! MAY NEED: running = doBet(); then running = getCards() as separate instructions. 
					
					//fault = nextHand(hand, handbuf, count, held, deal, delt, cardanims, c); //Do all hand arrangements. 
					//if ( fault >= MAX_SHUFFLE_FRAMES ) {
					//	//do machine error
					//}
					
				}
				
			
				Waitframe();
			}
			
					
					
			
		}
		
		void drawVPUI(int felt_x, int felt_y, int feltwidth, int feltheight, int feltcolour, int feltscale)
		{
			//Draw a black field
			Screen->Rectangle(1, VPUI_BLACK_BG_X, VPUI_BLACK_BG_Y, VPUI_BLACK_BG_X+VPUI_BLACK_BG_WIDTH, 
				VPUI_BLACK_BG_Y+VPUI_BLACK_BG_HEIGHT, VPUI_COLOUR_BLACK, VPUI_BLACK_BG_SCALE, 0,0,0,true, OP_OPAQUE);
			//Draw the felt
			Screen->Rectangle(1, felt_x, felt_y, felt_x+feltwidth, felt_y+feltheight, feltcolour, feltscale, 0,0,0,true, OP_OPAQUE);
			//Text draws go here, later. 
			
		}
		//Processes a bet and starts the game. 
		bool doBet(int bet, int counter, int sfx) 
		{ 
			if ( Game->Counter[counter] >= bet ) 
			{
				Game->DCounter -= bet;
				if ( sfx ) Game->PlaySound(sfx);
				return true;
			}
			return false;
		}
				
		
		//Shuffles deck and populates ten-card hand.
		//The hand is selected from a frame of ten cards from the shuffled pack, 
		//with the first entity on that frame randomised, and wrapping around if 
		//it reaches the array boundary. 
			//! This 10-card frame is an extra randomisation factor to minimise digital RNG favourability. 
		bool getCards(int deck, int hand)
		{
			int q = Rand(0,51); //Find the entry point of the frame.
			int w = q+10; int h;
			Shuffle(deck);
			for ( ; q < w; ++q ) { //Grab a frame of ten cards at random from the shuffled deck.
				if ( q <= 51 ) { hand[h] = deck[q]; h++; } //Populate the hand.
				if ( q >= 52 ) {
					q -= 52; h-= 52; //Wrap around
					hand[h] = deck[q]; h++; //Finish populating the hand. 
				}
			}
			return true; //boolean so that we can do:
					//	bool running = getCards(deck,hand);
		}
			
		void drawCards(int cardpositions, int hand, int cards, int suits){
			int q;
			int markings[13]={'A', '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K'};
			int suitcolours[4] = { CARD_SUIT_SPADES_COLOUR, CARD_SUIT_HEARTS_COLOUR, CARD_SUIT_DIAMONDS_COLOUR, CARD_SUIT_CLUBS_COLOUR };
			for ( q = 0; q < 5; ++q ) 
			{
				//Shadows
				Screen->Rectangle(VP_CARD_LAYER, cardpositions[q]+VP_CARD_SHADOW_X_OFFSET, VP_CARD_BASE_Y+VP_CARD_SHADOW_Y_OFFSET, 
					cardpositions[q]+VP_CARD_WIDTH+VP_CARD_SHADOW_X_OFFSET, VP_CARD_BASE_Y+VP_CARD_HEIGHT+VP_CARD_SHADOW_Y_OFFSET,
					VP_CARD_SHADOW, VP_CARD_SCALE, 0, 0, 0, true, VP_CARD_SHADOW_OPACITY); 
					//Card background
				Screen->Rectangle(VP_CARD_LAYER, cardpositions[q], VP_CARD_BASE_Y, VP_CARD_BASE_Y+VP_CARD_WIDTH, 
						cardpositions[q+1]+VP_CARD_HEIGHT, VP_CARD_COLOUR, VP_CARD_SCALE, 0, 0, 0, true, VP_CARD_OPACITY); 
				
				
				//Card pips and markers.
				
				//Pips
				//...to add. 
				
				//Markers
				Screen->DrawCharacter(VP_CARD_LAYER, cardpositions[q]+VP_CARD_CHAR_X_OFFSET, VP_CARD_BASE_Y+VP_CARD_CHAR_Y_OFFSET,
					VP_CARD_CHAR_FONT, suitcolours[ suits[ hand[q] ] ], VP_CARD_CHAR_BG_COLOUR, VP_CARD_CHAR_WIDTH, 
					VP_CARD_CHAR_HEIGHT, markings[ cards[ hand[q] ] ], VP_CARD_CHAR_OPACITY);
				
			}
		}

		void drawHeld(cardpositions, held)
		{ 
			for ( int q = 0; q < 10; q+= 2 )
			{
				//carspositions q = x, q+1 = y
				Screen->DrawString(VP_CARD_LAYER+1, cardpositions[q], cardpositions[q+1]+VP_CARD_HEIGHT+VP_CARD_HOLD_SPACING, VPUI_FONT, VPUI_HOLD_COLOUR, 
				VPUI_HOLD_BG_COLOUR, 0, "HOLD", OP_OPAQUE);
			}
		}
		
		int nextHand(int hand, int handbuf, int count, bool held, int deal, bool delt, bool cardanims, int c)
		{
			//!Needs to use Shuffle()
			c[5] = 0; //fault timer.
			
			//wipe dealt
			for ( c[1] = 0; c[1] < 52; c[1]++ ) { delt[ c[1] = false; }
			
			//wipe the pack
			for ( c[1] = 0; c[1] < 10; c[1]++ ) { deal[ c[1] ] = -1; }
				
			//clear the count
			for ( c[1] = 0; c[1] < 13; c[1]++ ) { count[ c[1] ] = 0; }
			
			for ( c[1] = 0; c[1] < 5; c[1]++ ) 
			{ 
				held[ c[1] ] = false; //clear held cards
				cardanims[ c[1] ] = false; //clear card anims
			}
			
			//! New hand
			//Populate the cards.
			for ( c[1] = 0; c[1] < 10; c[1]++ ) 
			{
				do 
				{
					c[0] = Rand(0,51);
					++c[5]; //fault timer
					
					//If we take too long to shuffe, raise a fault.
					if ( c[5] > MAX_SHUFFLE_FRAMES ) { return c[5]; }
					
				} while( dealt[ c[0] ] ); //If the card was dealt, choose another. 
				deal[ c[q] ] = c[0]; //Put the card in the deal pack. 
				dealt[ c[0] ] = true; //Mark the card dealt.
			}
		
			//Populate the hand wih the first five cards. 
			for ( c[1] = 0; c[1] < 5; C[1] ++ ) 
			{
				hand[ c[1] ] = deal[ [c[1] ];
			}
			
			
			for ( c[1] = 0; c[1] < 5; ++c[1] ) { handbuf[ c[1] ] = hand[ c[1] ]; //Copy to buffer. 
			

			} //refreshes the game for the next hand, retaining the betting values. 
			return 0;
			
			
		}
		int leaveGame() 
		{ 
			int s_leavegame[]="Äre you sure that you wish to quit?";
			int surety; 
			//Are you sure?
			//!INCOMPLETE MENU
			
			if ( KeyPress[KEY_Y] ) surety = 1;
			if ( KeyPress[KEY_N] ) surety = -1; 
			return surety; 
		}
		
		void setBets(int bets, int s_bets)
		{
			ItoA(bets,s_bets);
		}
			
		void displayBetline(int bets, int s_bets)
		{
			Screen->DrawString(BETS_LAYER, BETS_X, BETS_Y, BETS_FONT, BETS_COLOUR, BETS_BG_COLOUR, BETS_FORMAT,
			s_bets, OP_OPAQUE); 
		}
		
		//Fetch a string with the hand rank text into a buffer. 
		int getHandRankString(int buf, int handrank)
		{
		
			
			int strings[10]={	"High Card", "One Pair", "Two Pair", "Three of a Kind", "Straight", 
						"Flush", "Full House", "Four of a Kind", "Straight Flush", "Royal Flush"};
			
			int ptr = strings[handrank];
			//int sz = SizeOfArray(ptr);
			//int q;
			//for ( q = 0; q < sz; ++q ) { buf[q] = ptr[q]; }
			//buf[q+1] = NULL; //Terminate the string.
			strcpy(buf, ptr);
			return buf; //Return the pointer to the buffer on success. 
		}
		
		int doHandType(int hand, int cards, int counts, int min_pair)
		{
			bool pryle; int pairs; bool onepair; bool twopairs; 
			bool quads;  bool flush; bool straight;
			bool broadway; bool fullhouse;
			bool straightflush;
			bool royal;
			
			int hand_type; 

			flush = isFlush(hand,cards);
			straight = isStraight(hand,cards);
			broadway = isBroadway(hand,cards);
			if ( straight & flush ) straightflush = true;
			if ( broadway && flush ) royal = true;
			
			if ( !flush && !straight && !broadway ) 
			{
				hand_type = handRand(hand, cards, counts); 
				if ( hand_type == HT_ONEPAIR && min_pair > 0 ) 
				{
					if ( !minPair(counts, min_pair) ) return 0;
				}
			}
			if ( royal ) return HT_ROYAL;
			if ( straightflush ) return HT_STRAIGHTFLUSH;
			if ( flush ) return HT_FLUSH;
			if ( straight ) return HT_STRAIGHT;
			
			else return hand_type; //Quads, full house, trips, two pair, 
						//and one pair if ( the pair is > min_pair ) or 
						//there is no min pair. 
			
			//if ( quads ) return HT_QUADS;
			//if ( fullhouse ) return HT_FULLHOUSE;
			//if ( pryle ) return HT_TRIPS;
			//if ( twopairs ) return HT_TWOPAIR;
			//if ( onepair ) return HT_ONEPAIR;
			return 0; //Dead hand. 
		}
			
		bool isStraight(int hand, int cards)
		{

			int sorted[5];
			
			//store numeric values from cards[]
			for ( int q = 0; q < 5; ++q ) { 
				sorted[q] = cards[ hand[q] ]; //The numeric values. 
			}

			//Now, sort the array in a descending manner. 
			sortArray(cards, 5);
			//!
				
			bool match;
			
			for ( int q = 0; q < 4; ++q )  //Not all five. 
			{
				if ( sorted[q+1] == sorted[q] -1 ) { match = true };
				else match = false;
			}
			return match;
			
		}
		bool isBroadway(int hand, int cards) //A-10 Straight
		{ 
			int sorted[5];
			
			//store numeric values from cards[]
			for ( int q = 0; q < 5; ++q ) 
			{ 
				sorted[q] = cards[ hand[q] ]; //The numeric values. 
			}

			//Now, sort the array in a descending manner. 
			sortArray(cards, 5);
			//!
				
			bool match;
			
			for ( int q = 0; q < 3; ++q ) 
			{ //Check the first four, and read ito the fourth only. 
				if ( sorted[q+1] == sorted[q] -1 ) { match = true };
				else match = false;
			}
			if ( sorted[5] != 1 ) { match = false; } //it must be an Ace. 
			return match;
			
		} 
		bool isFlush(int hand, int suits) 
		{ 
			int suit; 
			bool match;
			suit = suits[ hand[0] ];
			for ( int q = 1; q < 5; ++q ) 
			{
				if ( suits[ hand[q] ] == suit ) { match = true; }
				else match = false;
			}
			return match;
			
		}
		
		//Hand ranks using matched cards. 
		int handRank(int counts)
		{
			int pairs;
			bool pryle;
			bool quads;
			bool fullhouse; 
			for ( int q = 0; q < 13; ++q ) 
			{ 
				if ( counts[q] == 4 ) quads = true;
				if ( counts[q] == 3 ) pryle = true;
				if ( counts[q] == 2 ) ++pairs;
			}
			if(pryle)
			{
				switch(pairs)
				{
					case 1: return HT_FULLHOUSE;
					default: return HT_TRIPS;
				}
			}
			else
			{
				switch(pairs)
				{
					case 2: return HT_TWOPAIR
					case 1: return HT_ONEPAIR;
					case 0: return 0;
				}
			}
		}
		
		//If only one pair, checks that the pair is at at least the minimum type. 
		bool minPair(int counts, int highcard)
		{
			int card; 
			for ( card = 0; card < 13; card++ ) 
			{
				if ( counts[q] == 2 ) { break; }
			}
			if ( card >= (highcard -1) ) return true; 
			return false; 
		}
			
		void doOdds(int handtype)
		{
			//int odds[] = { 	ODDS_NOPAIR, ODDS_PAIR, ODDS_TWOPAIR, ODDS_TRIPS, ODDS_STRAIGHT, ODDS_FLUSH, 
			//		ODDS_FULLHOUSE, ODDS_QUADS, ODDS_STRAIGHTFLUSH, ODDS_ROYAL } ;
			
			int payout[] = { 0, 1, 2, 3, 4, 6, 9, 25, 50, 800 }; 
			return payout[handtype];
		}

		//Draw the cards. Populates the un-held slots in the present hand with the preselected cards.
		void doDraw(int deal, int held, int hand ) 
		{
			for ( int q = 0; q < 5; ++q ) 
			{
				unless ( held[q] ) 
				{ 
					hand[q] = deal[q+5];
				}
			}
		}
		
		void sortArray(int ptr, int size) 
		{
			unless(IsValidArray(ptr))
			{
				printf("Invalid array passed to sortArray\n");
				return;
			}
			if (size < 2) {return;}

			for (int i = 1; i < size; ++i) 
			{
				int j = i;
				int j_val = ptr[j];
				while (j > 0) 
				{
					if (ptr[j - 1] <= j_val) {break;}
					int temp = ptr[j - 1];
					ptr[j - 1] = ptr[j];
					ptr[j] = temp;
					--j;
				}
			}
		}
		
		void doCounts(int cards, int hand, int counts) 
		{
			int pairs = 0;
			for (int i = 0; i < 5; ++i) 
			{
				int rank = cards[hand[i]];
				++counts[rank - 1];
				//if (counts[rank - 1] % 2 == 0) pairs++;
			}
			//return pairs;
		}
		
		
		
		
	}
}

/*
int countPairs(int cards, int hand) {
 int counts[13];
 int pairs = 0;
 for (int i = 0; i < 5; ++i) {
  int rank = cards[hand[i]];
  counts[rank - 1]++;
  if (counts[rank - 1] % 2 == 0) pairs++;
 }
 return pairs;
}

*/