Blackjack Game in C++

 Posted by Samath   3288 January 05, 2017

Blackjack, also known as twenty-one, is the most widely played casino banking game in the world. Blackjack is a comparing card game between a player and dealer, meaning players compete against the dealer but not against other players. It is played with one or more decks of 52 cards. The objective of the game is to beat the dealer in one of the following ways:

1. Get 21 points on the player's first two cards (called a "blackjack" or "natural"), without a dealer blackjack;
2. Reach a final score higher than the dealer without exceeding 21; or
3. Let the dealer draw additional cards until his or her hand exceeds 21.

```//Include libraries
#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <ctime>
#include <limits>

//Declare namespace
using namespace std;

//Prototype functions.
int getRandomNumber(int low, int high);
int CardValue(int card);
int getTopCard(int deck[]);
int getHandValue(const int hand[]);
bool playAnotherHand(char&);
bool userWantsToDraw(char&);
void initializeDeck(int deck[]);
void dumpDeck(int deck[], int size);
void shuffle(int deck[], int size);
void ShowCard(int card);
void showCards(const int cards[], int numCards, bool hideFirstCard);
void whoWins(const int pHand[], const int dHand[]);
void checkBust(const int pHand[], const int dHand[], char Play);
void blackJack(const int pHand[], const int dHand[], char Play);
void naturalBlackJack(const int pHand[], const int dHand[], char Play);
void playOneHand();
void scoreBoard(const int pHand[], const int dHand[]);
void backdoorKenny(const int hand[]);
void checkSoftOrHard(int pHand[]);
void softOrHardAI(int dHand[], int pHand[]);
void chooseLevelOfDificulty();
void showRules();
void hitUntilStand(int dHand[], int deck[], int pHand[]);

//Declare global Variables
int topCard = 0;
float win = 1.00;
int level;

int main()
{
showRules();
chooseLevelOfDificulty();
playOneHand();
return 1;
}

/* ==================================================
Name: showRules
Desc: Displays the game rules
Parameters:
None.
Return:
void.
================================================== */
void showRules()
{
//Display rules and information in a visually pleasing graphic.
cout << "//////////////////////////////////////////////////////////" << endl;
cout << "////        Welcome to the game of Twenty One!       /////" << endl;
cout << "////  _____________________________________________  /////" << endl;
cout << "//// | Rules:                                      | /////" << endl;
cout << "//// | o Aces can be either 1 or 11 points.        | /////" << endl;
cout << "//// | o Dealer wins ties unless player has a      | /////" << endl;
cout << "//// |   blackjack.                                | /////" << endl;
cout << "//// |                                             | /////" << endl;
cout << "//// | Winnings -                                  | /////" << endl;
cout << "//// | Winnings are based on the weight of a given | /////" << endl;
cout << "//// | win or loss:                                | /////" << endl;
cout << "//// | o Your score beats Dealer's score -         | /////" << endl;
cout << "//// |   1:1 payout ratio.                         | /////" << endl;
cout << "//// |   (100% increase of your initial bet.)      | /////" << endl;
cout << "//// | o Dealer's score beats your score -         | /////" << endl;
cout << "//// |   1:1 loss ratio.                           | /////" << endl;
cout << "//// |   (100% decrease of your initial bet.)      | /////" << endl;
cout << "//// | o Blackjack -                               | /////" << endl;
cout << "//// |   3:2 payout ratio.                         | /////" << endl;
cout << "//// |   (150% increase of your initial bet.)      | /////" << endl;
cout << "//// | o Natural Blackjack (A in two. Auto win) -  | /////" << endl;
cout << "//// |   3:2 payout ratio.                         | /////" << endl;
cout << "//// |   (150% increase of your initial bet.)      | /////" << endl;
cout << "//// | o Backdoor Kenny (Face then A in two) -     | /////" << endl;
cout << "//// |   1:4 payout ratio.                         | /////" << endl;
cout << "//// |   (25% increase of your initial bet.)       | /////" << endl;
cout << "//// | o Push (Tie) -                              | /////" << endl;
cout << "//// |   i.  1:1 payout if in your favor.          | /////" << endl;
cout << "//// |       (100% increase of your initial bet.)  | /////" << endl;
cout << "//// |   ii. 0:1 payout if in Dealer's favor.      | /////" << endl;
cout << "//// |       (No loss, no gain.)                   | /////" << endl;
cout << "//// |                                             | /////" << endl;
cout << "//// | These odds determine your winnings          | /////" << endl;
cout << "//// | multiplier. If you are in a betting mood,   | /////" << endl;
cout << "//// | you can place a bet and multiply it by your | /////" << endl;
cout << "//// | winnings multiplier at the end of the game  | /////" << endl;
cout << "//// | to see how much you win. Feel free to give  | /////" << endl;
cout << "//// | me your negative winnings!                  | /////" << endl;
cout << "//// |_____________________________________________| /////" << endl;
cout << "//////////////////////////////////////////////////////////" << endl;
cout << "////              Level of Difficulty                /////" << endl;
cout << "////  _____________________________________________  /////" << endl;
cout << "//// | You may choose to play with a beginner or   | /////" << endl;
cout << "//// | expert Dealer:                              | /////" << endl;
cout << "//// | o (Beginner) - Dealer stands at a soft 17   | /////" << endl;
cout << "//// |                and has no AI.               | /////" << endl;
cout << "//// | o (Expert)   - Dealer hits at a soft 17     | /////" << endl;
cout << "//// |                and has AI.                  | /////" << endl;
cout << "//// |_____________________________________________| /////" << endl;
cout << "//////////////////////////////////////////////////////////" << endl;
}

/* ==================================================
Name: chooseLevelOfDificulty
Desc: Prompt Player for desired level of difficulty.
Use Dealer's AI for Expert, don't use AI for
Beginner.
Parameters:
None
Return:
void
================================================== */
void chooseLevelOfDificulty()
{
//Prompt user and store input
cout << "\n";
cout << "Level of Difficulty: Beginner (1), Expert (2). ";
cin >> level;
cout << "\n";

//If input is not a 1..
if(level != 1)
{
//...or a 2.
if(level != 2)
{
//Clears input error flags and removes everything currently in the input buffer.
cin.clear();
cin.ignore(numeric_limits<streamsize>::max(), '\n');

//Display error message and restart function.
cout << "Please enter your level of difficulty using the number 1 or 2." << endl;
chooseLevelOfDificulty();
}
}
}

/* ==================================================
Name: playOneHand
Desc: Main game logic.
Parameters:
None.
Return:
void.
================================================== */
void playOneHand()
{
//Declare local variable
char Play = 'N';

//Start the game at least once and repeat while Player wants to.
do
{
//Declare local variable
char Draw = 'H';

//Declare, initialize and shuffle the deck.
int deck[52];
initializeDeck(deck);
shuffle(deck, 51);

//Declare and initialize Player and Dealer hands.
int pHand[10] = {0};
int dHand[10] = {0};

//Deal first round

//Display an explanation  of what is happening
cout << "//////////////////////////////////////////////////////////" << endl;
cout << "\n" << endl;
cout << "The Dealer shuffled and dealt you each your cards. ";
cout << "\n" << endl;

//Check for an automatic win.
naturalBlackJack(pHand, dHand, 'y');
blackJack(pHand, dHand, 'Y');

//Display Player and Dealer hands
cout << "Your hand:" << endl;
showCards(pHand, 10, false);
cout << "\n\nDealer's hand:" << endl;
showCards(dHand, 10, true);

//If Player has an Ace, see if Player want's to have a soft or hard hand.
checkSoftOrHard(pHand);

//Check if user wants to hit
while (userWantsToDraw(Draw))
{
//Deal Player a card
//and display an explanation  of what is happening
cout << "The Dealer dealt you another card.\n" << endl;

//Display Player's updated hand
cout << "Your hand:" << endl;
showCards(pHand, 10, false);

//If Player has an Ace, see if Player want's to have a soft or hard hand.
checkSoftOrHard(pHand);

//Check to see if anyone lost
checkBust(pHand, dHand, 'y');

//Check to see if anyone won
blackJack(pHand, dHand, 'Y');
}

//Dealer hits until at a soft 17
hitUntilStand(dHand, deck, pHand);
cout << endl;

//Check to see if anyone lost
checkBust(pHand, dHand, 'Y');

//Check to see if anyone won
blackJack(pHand, dHand, 'Y');

//Compare scores and determine winner
whoWins(pHand, dHand);
cout << endl;

//Display updated winnings multiplier
cout << "Winnings multiplier: " << win << endl;
}
while (playAnotherHand(Play));
}

/* ==================================================
Name: initializeDeck
Desc: Create the cards background values so that suit
is in the 100s place and rank is in the 10s place.
Parameters:
deck (int) - System generated.
Return:
void
================================================== */
void initializeDeck(int deck[])
{
//Declare local variables.
int Rank = 101;
int i = 0;

//Hearts
for (i = 0 ; i<=13; i++)
{
deck[i] = Rank++;
}

//Diamonds
for (i = 13 ; i<=26; i++)
{
deck[i] = Rank++ + 100 - 14;
}

//Clubs
for (i = 26 ; i<=39; i++)
{
deck[i] = Rank++ + 200 - 28;
}

for (i = 39 ; i<=51; i++)
{
deck[i] = Rank++ + 300 - 42;
}
}

/* ==================================================
Name: shuffle
Desc: Randomly rearranges the cards in the given
52-card deck.
Parameters:
deck (int) - System generated.
size (int) - Programmer generated.
Return:
void
================================================== */
void shuffle(int deck[], int size)
{
//Loop through deck an absurd amount of loops.
for(int i = 0; i < 500; i++)
{
//Define local variables
int T1 = 0;
int R1 = getRandomNumber(0, size);
int R2 = getRandomNumber(0, size);

//Clone first card for safe keeping
//Replace first card with a new card
//Replace the new card with the old card clone
T1	= deck[R1];
deck[R1] = deck[R2];
deck[R2] = T1;
}
}

/* ==================================================
Name: ShowCard
Desc: Displays the given card's rank and suit.
Parameters:
card (int) - System generated.
Return:
void
================================================== */
void ShowCard(int card)
{
//Show nothing for non cards (ie.0)
if(card == 0)
{
cout << "";
}
//Define Ranks.
else
{
switch(card % 100)
{
case 1:
cout << "A";
break;
case 11:
cout << "J";
break;
case 12:
cout << "K";
break;
case 13:
cout << "Q";
break;
case 14://14 is a value created in checkSoftOrHard
cout << "A";
break;

//For non-face cards, just use their 10s value as rank.
default:
cout << card % 100;
}
}

//Show nothing for non cards (ie.0)
if(card == 0)
{
cout << "";
}
//Define Suits.
else
{
//Hearts
if((card >= 101) && (card <=114))
{
cout << static_cast<char>(3);
}

//Diamonds
else if ((card >= 201) && (card <= 214))
{
cout << static_cast<char>(4);
}

//Clubs
else if ((card >= 301) && (card <= 314))
{
cout << static_cast<char>(5);
}

else if ((card >= 401) && (card <= 414))
{
cout << static_cast<char>(6);
}
}
}

/* ==================================================
Name: ShowCards
Desc: Displays the given card?s rank and suit.
Parameters:
deck (int) - System generated.
numCards (int) - Programmer generated.
hideFirstCard (bool) - Programmer generated.
Return:
void
================================================== */
void showCards(const int deck[], int numCards, bool hideFirstCard)
{
//Hide dealer's first card if true.
if(hideFirstCard)
{
cout << "** ";
}

//Show dealer's first card if false.
else
{
ShowCard(deck[0]);
cout << " ";
}

//Display all the cards in the deck or hand
//by showing their rank and suit graphic.
for(int i = 1; i < numCards; i++)
{
//Show cards
if(deck[i] != 0)
{
ShowCard(deck[i]);
cout << " ";
}

//Show nothing for non cards (ie. 0).
else
{
cout << "";
}
}
}

/* ==================================================
Name: dumpDeck
Desc: Loop through the deck array and print each value.
Parameters:
deck (int) - System generated.
size (int) - Programmer generated.
Return:
void
================================================== */
void dumpDeck(int deck[], int size)
{
//loop through the deck array and print each value.
for(int i = 0; i < size; i++)
{
cout << i + 1 << ".) " << deck[i] << endl;
}
}

//================================================================
// Function:    getRandomNumber
// Description: returns a random number between given low and high
//	values, inclusive.
//	Note: include cstdlib (for rand) and ctime (for time).
// Arguments:
//	low (I) - The lowest number to be generated
//	high (I) - The highest number to be generated (must be > low)
// Return value:
//	A random number between low and high (inclusive)
//================================================================
int getRandomNumber(int low, int high) {
static bool firstTime=true;
int randNum;

//if first time called, seed random number generator
if (firstTime) {
srand( static_cast<unsigned int>(time(NULL)) );
firstTime=false;
}

//generate random number between given low and high values (inclusive)
randNum = rand() % (high-low+1) + low;

return randNum;
}

/* ==================================================
Name: CardValue
Desc: Returns a given card's value.
Parameters:
card (int) - Any one given card.
Return:
int - The given Card's Value.
================================================== */
int CardValue(int card)
{
//Declare local variable
int cardVal;

//Get the card's background 10s value and assign the card a point value
switch(card % 100)
{
case 1:
cardVal = 11;
break;
case 11:
case 12:
case 13:
cardVal = 10;
break;
case 14:
cardVal = 1;
break;
//For non-face cards, just use their backround 10s value as point value.
default:
cardVal = (card % 100);
}
return cardVal;
}

/* ==================================================
Name: getTopCard
Desc: Returns the “top” card off the deck.
Parameters:
deck[] (int) - The game deck.
Return:
int - The given Card's Value.
================================================== */
int getTopCard(int deck[])
{
//Loop through the deck
for(int i = 0; i < 51; i++)
{
//Find a card that isn't empty
if(deck[i] != 0)
{
//Clone card for safe keeping
//Replace first card with the empty card value
//Return the clone of the card
topCard = deck[i];
deck[i] = 0;
}
}
}

/* ==================================================
Desc: Adds the given card to an array representing a
players hand.
Parameters:
hand[] (int) - A given hand.
cardToAdd (int) - A card to add (always the top card from the deck).
Return:
void
================================================== */
{
//Loop through the hand
for(int i = 0; i < 9; i++)
{
//If there is an empty card spot
if(hand[i] == 0)
{
//Replace it with the card to add
break;//Only do this once by breaking the loop
}
}
}

/* ==================================================
Name: hitUntilStand
Desc: Background logic to make the dealer hit until a soft 17.

Parameters:
dHand[] (int) - A given hand, but intended to always be the Dealer's hand.
deck[] (int) - The game deck.
pHand[] (int) - A given hand, but intended to always be the Player's hand.
Return:
void
================================================== */
void hitUntilStand(int dHand[], int deck[], int pHand[])
{
//Loop through Dealer's hand
for(int i = 0; i < 9; i++)
{
/*
//If Player is an Expert
if( level == 2)
{
//Loop through Dealer's hand
for( int i = 0; i < 9; i++)
{
//Find a default Ace (11pts)
if(CardValue(dHand[i]) == 11)
{
//Change Aces from default 11(soft) to 1(hard)
dHand[i] = dHand[i] + 13; // A hard Ace (worth 1 point) has a background value ending in 14
}
}
}

//do nothing and clear this if of an else for the next if.
else;
*/

//If Dealer must hit
if(getHandValue(dHand) < 17)
{
//If Player chose Beginner level dealer stands at soft 17
if(level == 1)
{
//...add a card to the hand
}

//If Player chose Expert level dealer stands at Hard 17
else if( level == 2)
{
//...add a card to the hand

//Ensure Aces are handled intelligently to beat Player
softOrHardAI(dHand, pHand);
}
}
//Display how many cards Dealer hit if Dealer has 17 or more points...
else
{
//Dealer didn't hit to get to 17
if(i == 0)
{
cout << "The Dealer stands." << endl;
break;
}
//Dealer hit once to get to 17
else if(i == 1)
{
cout << "The Dealer hit a card and stands." << endl;
break;
}
//Dealer hit more than once to get to 17
else
{
cout << "The Dealer hit " << i << " cards and stands." << endl;
break;
}
}

//Run dealer AI again if player chose to play Expert
//This is called again for the sake of redundancy.
if(level == 1);
else if( level == 2)
{
softOrHardAI(dHand, pHand);
}
}
}

/* ==================================================
Name: getHandValue
Desc: Computes and returns the value of the given hand.
Parameters:
hand[] (const int) - A given hand.
Return:
addCardValues (int) - Value of the given hand.
================================================== */
int getHandValue(const int hand[])
{
//Declare local variables
int addCardValues = 0;

//Loop through the hand and add up the card values
for(int i = 0; i < 9; i++)
{
}

//Give the sum of the card values as the hand value
}

/* ==================================================
Name: playAnotherHand
Desc: Prompts user for input and determines if the
user will play another hand.
Parameters:
Play (char) - User generated input.
Return:
false (bool) - Player doesn't want to play anymore.
==================================================*/
bool playAnotherHand(char& Play)
{
//Prompt user to see if they would like to play another hand.
cout << endl << "\nWould you like to play another hand? (Y/N) ";
cin >> Play;
cout << "\n" << endl;

//Go back to the main game logic function to restart if they do.
if(Play == 'y' || Play == 'Y')
{
playOneHand();
return(true);
}
//If they don't, exit the program.
else
{
return(false);
}
}

//================================================================
// Function:    userWantsToDraw
// Description: Determines if user wants to hit.
// Input Arguments:
//				Draw (char) - the character entered by the user
// Return value:
//				True (bool) - Start loop.
// 				False (bool) - Skip loop.
//=================================================================
bool userWantsToDraw(char& Draw)
{
//Prompt user to see if they would like to enter a new time.
cout << endl << "\nWould you like to hit or stand? (H/S) ";
cin >> Draw;
cout << "\n";

//If they do, return true and start the loop to draw another card.
if(Draw == 'h' || Draw == 'H')
{
return(true);
}
//If they don't, skip the loop.
else
{
return(false);
}
}

/* ==================================================
Name: whoWins
Desc: Determines the winner based off of hand point
value comparison.
Parameters:
pHand[] (int) - Player's hand.
dHand[] (int) - Dealer's hand.
Return:
void
================================================== */
void whoWins(const int pHand[], const int dHand[])
{
//Declare local variables
int playerScore = getHandValue(pHand);
int dealerScore = getHandValue(dHand);

//Display the scoreboard
scoreBoard(pHand,  dHand);

//win tree
//If Player scores less than 22
if( (playerScore < 22)
//If Player's score is better than Dealer's score
&& (playerScore > dealerScore)
//If Player's score is under 22 but Dealer's score is over 21
|| ( (dealerScore > 21)
&& (playerScore < 22) ) )
{
//Display message and compute new winnings multiplier
cout << "\n";
cout << "You win!" << endl;
win++;
}
//loos tree
//If you don't win, you lose or tie.
else
{
//Tie
//Display message
if(playerScore == dealerScore)
{
cout << "\n";
cout << "Push in the Dealer's favor. 0:1 payout." << endl;
}

//loose
//Display message and compute new winnings multiplier
else
{
cout << "\n";
cout << "You lose." << endl;
win--;
}
}
}

/* ==================================================
Name: check Bust
Desc: See Player or Dealer bust 21
Parameters:
pHand[] (int) - Player's hand.
dHand[] (int) - Dealer's hand.
Play (char) - User generated input.
Return:
void
================================================== */
void checkBust(const int pHand[], const int dHand[], char Play)
{
//Define local variables.
int playerScore = getHandValue(pHand);
int dealerScore = getHandValue(dHand);

//Check if Player busts.
//Display message, compute new winnings multiplier, ask to play another hand.
if(playerScore > 21)
{
cout << "You bust with " << getHandValue(pHand) << " points." << endl;
cout << "\n" << endl;
win--;
cout << "Winnings multiplier: " << win << endl;
playAnotherHand(Play);
}

//Check if Dealer busts.
//Display message, compute new winnings multiplier, ask to play another hand.
else if(dealerScore > 21)
{
scoreBoard(pHand,  dHand);
cout << "\n" << endl;
cout << "The Dealer went bust. You Win!" << endl;
cout << "\n" << endl;
win++;
cout << "Winnings multiplier: " << win << endl;
playAnotherHand(Play);
}
}

/* ==================================================
Name: backdoorKenny
Desc: Checks to see if a given hand has a Backdoor Kenny.
Any card valued at 10 points followed by an Ace as
the first two cards in the deck.
Parameters:
pHand[] (int) - Player's hand.
dHand[] (int) - Dealer's hand.
Play (char) - User generated input.
Return:
void
================================================== */
void backdoorKenny(const int hand[])
{
//If index 0 is a 10 and index 1 is an ace
if((CardValue(hand[0])%100 == 10)&&(CardValue(hand[1])%100 == 11))//I did not use 1 as an argument because 11 is the default
//value and this happens before the user can choose.
{
//Display message and compute new winnings multiplier.
cout << "\n\n";
cout << "You pulled a Backdoor Kenny!\n" << endl;
cout << "Win an additional 1:4 payout\n" << endl;
win = win + .25;
cout << "Winnings multiplier: " << win << endl;
}
}

/* ==================================================
Name: blackJack
Desc: Checks to see if a given hand has a blackjack.
Parameters:
pHand[] (int) - Player's hand.
dHand[] (int) - Dealer's hand.
Play (char) - User generated input.
Return:
void
================================================== */
void blackJack(const int pHand[], const int dHand[], char Play)
{
//Define local Variables
int playerScore = getHandValue(pHand);
int dealerScore = getHandValue(dHand);

//If Player has blackjack but Dealer doesn't.
if((playerScore == 21) && (dealerScore != 21))
{
//Display message, compute new winnings multiplier, ask to play another hand.
cout << "\n\n";
scoreBoard(pHand,  dHand);
cout << "\n";
cout << "Blackjack! You win a 3:2 payout." << endl;
win = win + 1.5;
cout << "\n";
cout << "Winnings multiplier: " << win << endl;
backdoorKenny(pHand);
playAnotherHand(Play);
}
//If both Player and Dealer have blackjack.
else if((playerScore == 21) && (dealerScore == 21))
{
//Display message, compute new winnings multiplier, ask to play another hand.
scoreBoard(pHand,  dHand);
cout << "\n";
cout << "The Dealer and you both got Blackjack. Push in your favor at 1:1 payout!" << endl;
win++;
cout << "\n";
cout << "Winnings multiplier: " << win << endl;
playAnotherHand(Play);
}
}

/* ==================================================
Name: naturalBlackJack
Desc: Checks to see if a given hand has a blackjack.
Parameters:
pHand[] (int) - Player's hand.
dHand[] (int) - Dealer's hand.
Play (char) - User generated input.
Return:
void
================================================== */
void naturalBlackJack(const int pHand[], const int dHand[], char Play)
{
//Define local variables
int playerScore = getHandValue(pHand);
int dealerScore = getHandValue(dHand);

//If Player has blackjack and Dealer doesnt
if((playerScore == 21) && (dealerScore != 21))
{
//Display message, compute new winnings multiplier, ask to play another hand.
scoreBoard(pHand,  dHand);
cout << "\n";
cout << "Natural Blackjack! You win a 3:2 payout.";
win = win + 1.5;
backdoorKenny(pHand);
playAnotherHand(Play);
}
}

/* ==================================================
Name: scoreBoard
Desc: Displays a simple score board with both the
cards in each hand and the total points for
each hand.
Parameters:
pHand[] (int) - Player's hand.
dHand[] (int) - Dealer's hand.
Return:
void
================================================== */
void scoreBoard(const int pHand[], const int dHand[])
{
//Display Player's cards/hand value
cout << "Player hand: ";
showCards(pHand, 10, false);
cout << " ("<< getHandValue(pHand) << "pts)."<<endl;

cout <<"V.S." << endl;

//Display Dealer's cards/hand value
cout << "Dealer hand: ";
showCards(dHand, 10, false);
cout << " ("<< getHandValue(dHand) << "pts)."<<endl;
}

/* ==================================================
Name: checkSoftOrHard
Desc: Asks Player if they would like their Ace to
count as 1 or 11 points and then computes those
changes.
Parameters:
pHand[] (int) - Player's hand.
dHand[] (int) - Dealer's hand.
Return:
void
================================================== */
void checkSoftOrHard(int pHand[])
{
//check cards in hand
for(int i=0; i<9; i++)
{
//Define local variables.
int checkAce = CardValue(pHand[i]);
int softOrHard;

//If card in hand is an Ace prompt Player for input
if(checkAce == 1 || checkAce == 11)
{
cout << "\n";
cout << "\nWould you like your Ace to count as 1 or 11 points? (1/11): ";
cin >> softOrHard;

//If Player chooses 1
if(softOrHard == 1)
{
if(checkAce == 11)
pHand[i] = pHand[i] + 13;
}

//If Player chooses 11
else if(softOrHard == 11)
{
if(checkAce == 1)
{
pHand[i] = pHand[i] - 13;
}
}

//If player doesn't input 1 or 11
else if (softOrHard != 1 || softOrHard != 11)
{
//Clears input error flags and removes everything currently in the input buffer.
cin.clear();
cin.ignore(numeric_limits<streamsize>::max(), '\n');

//Display error message and restart the function
cout << "\nPlease enter the number 1 or 11." << endl;
checkSoftOrHard(pHand);
}
}
}
}

/* ==================================================
Name: checkSoftOrHardAI
Desc: Logical test based on if Dealer has an Ace.
If Dealer does have an Ace Dealer should see if
Dealer can make Dealer's hand 21, if not make
Dealer's hand beat Player's hand with out
going over 21.
Parameters:
pHand[] (int) - Player's hand.
dHand[] (int) - Dealer's hand.
Return:
void
================================================== */
void softOrHardAI(int dHand[], int pHand[])
{
//check cards in hand
for(int i=0; i<9; i++)
{
//Find an Ace
if(CardValue(dHand[i]) == 1 || CardValue(dHand[i]) == 11)
{
//If the Ace is worth 11 points...
if(CardValue(dHand[i]) == 11)
{
//...change it to 1 point if that will beat player...
if (getHandValue(dHand) - CardValue(dHand[i]) + 1 > getHandValue(pHand))
{
//...and not bust.
if (getHandValue(dHand) - CardValue(dHand[i]) + 1 < 22)
{
dHand[i] = dHand[i] + 13;
}
}

//Else if hand is a bust at 11, make it 1
else if (getHandValue(dHand) > 21)
{
dHand[i] = dHand[i] + 13;
}
}

//Else Ace is worth 1 point.
else
{
//Change it to 11 points if that will beat player...
if (getHandValue(dHand) - CardValue(dHand[i]) + 11 > getHandValue(pHand))
{
//...and not bust.
if (getHandValue(dHand) - CardValue(dHand[i]) + 11 < 22)
{
dHand[i] = dHand[i] - 13;
}
}
}
}
}
}

```