IC210: Project 2 -- Blackjack

Blackjack

Executive Summary

You will implement a fully functioning game of Blackjack. No prior knowledge of the game is needed. However, you will need to know what cards appear in a standard deck of playing cards. See your instructor if you have any questions on that account.

Blackjack (also called "21") is basically a game between an individual player and a dealer. There's a gambling side to the game that this project does not address. The project simply plays the game with the user as "Player" and program as "Dealer", and determines the winner and loser.

Honor:
The course policy and the instructions it references, most pertinently COMPSCIDEPTINST 1531.1D, spell out what kinds of assistance are permissible for programming projects. The instructor can give explicit permission for things that would otherwise not be allowed. For this project, you are allowed

to get help from other current IC210 instructors as well as your own and from current IC210 MGSP leaders (any assistance must be documented though), and
to use general purpose C++ resources online (though such use must be documented).

For this project, you are not allowed to do the following:

Resources that might specifically address this project, say looking through code that implements blackjack or other card games, are not allowed.
You are very specifically not allowed to look at previous semesters' IC210 or SI204 programming project or lab solutions that may have addressed similar issues.

Combining the instructions referenced in the course policy and the explicit permissions above, and what you get is summarized as:

The only help you may receive on a project is from your instructor or the other IC210 instructors and IC210 MGSP leaders, and that help must be clearly cited. In turn, you cannot provide help to any IC210 students on this project.
In no circumstance - project, homework or lab - may you copy code and submit it as your own work. That is the definition of plagiarism.
For projects, you may not look at other people's project code nor may you show your own code to others.
You can look at online (or other electronic or print) resources for general purpose C++ programming, but not for help writing card game programs or anything else that is specific to the functionality required of your project. So, for example, you may not look at code for a program that plays a card game.

Warning: Do not even vaguely talk about the contents of the project with your colleagues.

Grading

70% of your grade will be based on functionality (i.e., whether your program works as specified), mostly based on the test cases that you see when you submit, but perhaps also extra test cases according to the specifications of the project. The code you submit must work if you expect to earn a passing grade.

30% of your grade will be based on coding style, which includes:

Readability: You should use good spacing and proper indentation, and avoid long lines longer than 80 characters.
Documentation: Use meaningful variable names and write helpful comments to make it obvious what your code is doing.
Design: Make sure you do a good job of putting things in functions. One monolithic main function is not OK, even if it works! The quality of your overall design will play a role, and a large part of that boils down to using functions well.

Deadlines

Parts 1-3: Due 0800 on Friday, October 22.
You must pass all test cases in the submission server for Parts 1-3.
The full project: Due 0800 on Friday, October 29.

Early bonus and late penalty

For Parts 1-3
- 5% penalty for any late submissions.
For the final project:
- 1 day early: 5% bonus
- 1 day late: 10% penalty
- 2 days late: 40% penalty
- 3 or more days late: 100% penalty

Submit

Electronic submission: Once you complete each part, submit your work to the submit server with the command
~/bin/submit -c=IC210 -p=proj02 *.cpp
Paper submission for full project only: Print and fill in this coversheet and turn it in before class starts on the day the project is due.

Part 1 [up to 10pts]: Printing out a deck of cards

A part 1 solution (p1.cpp) will create a deck of cards, printing out the cards represented as integers.

Sample run

~/$ ./p1
[102 103 104 105 106 107 108 109 110 111 112 113 114 202 203 204 205 206 207 208 209 210 211 212 213 214 302 303 304 305 306 307 308 309 310 311 312 313 314 402 403 404 405 406 407 408 409 410 411 412 413 414]

Explanation: Storing a card as an integer

Each card will be represented by a single integer cardvalue in the following way:

Face values are represented as follows:

2 = 2, 3 = 3, ..., 10 = 10, 11 = J(jack), 12 = Q(queen), 13 = K(king), 14 = A(ace)

Suits are represented as follows:

1 = ♣ (clubs), 2 = ♦ (diamonds), 3 = ♥ (hearts), 4 = ♠
(spades)

Combining the above, each card is represented as follows:
```
cardvalue =  facevalue + 100 × suitvalue
```
Note this also means that for an integer variable cardvalue, one can compute suitvalue and facevalue as follows:
```
facevalue = cardvalue % 100
suitvalue = cardvalue / 100
```

Example:

K♠ → (facevalue=13,suitvalue=4) → 13 + 100*4  → 413

Ordering of the cards in the deck

The card numbers in your deck should be ordered numerically in increasing order. In other words, your program should work as follows:

The deck will start with the 2 of clubs up to the ace of clubs;
then all the diamonds;
then all the hearts;
then all the spades (ending with the ace of spades).

Part 2 [up to 25pts]: Simulation of Dealing Cards

Copy p1.cpp to p2.cpp. Now, after creating a deck as in Part 1, let's simulate dealing cards to a "Player" and a "Dealer". Read the following rules slowly and carefully:

Deal one card to "Player," one to "Dealer", one to "Player", and one to "Dealer" (so both have two cards). Then display the hands.
Deal one card to "Player," then one card to "Dealer". Then display the hands.
Deal one card to "Player," then one card to "Dealer". Then display the hands.
Deal one card to "Player," then one card to "Dealer". Then display the hands.

~/$ ./p2
[102 103 104 105 106 107 108 109 110 111 112 113 114 202 203 204 205 206 207 208 209 210 211 212 213 214 302 303 304 305 306 307 
308 309 310 311 312 313 314 402 403 404 405 406 407 408 409 410 411 412 413 414]

Player: [102 104]
Dealer: [103 105]

Player: [102 104 106]
Dealer: [103 105 107]

Player: [102 104 106 108]
Dealer: [103 105 107 109]

Player: [102 104 106 108 110]
Dealer: [103 105 107 109 111]

Dealing a card:

Of course, dealing a card means as following:

 Take the card on the top of the deck and hand it to the player (or the dealer).

In our context, the top of the deck is the first card printed in Part 1

Programming Tip:

You really want to have your program simulate dealing a card to a hand.
Q: What would be a good way to represent the player's (respectively the dealer's) hand?
Make sure you do a good job of putting things in functions.
- One monolithic main function is not OK, even if it works! Well, in fact, it will be very very difficult to make things work with only a main function.

Part 3 [up to 45pts]: Hit or Stand

Copy p2.cpp to p3.cpp. Now let's play something that actually looks like a game.

At first, Player and Dealer will both be dealt two cards (as we did in Part2).
But then the program will proceed to ask the Player and Dealer in turns which of the following they want:
- "hit": In this case, they get dealt another card into their hand, or
- "stand": In this case, their hand stays the same.
[Note: In this project, the player or dealer can "stand" and then "hit" in the next round — which is not allowed in real blackjack.]
The player goes first, and the program should go through three rounds (i.e. the Player and the Dealer both get three turns).

Below is an example of how a game might play out (red text represents user input). Your output and the way you get input from the user must match what's shown here.

Sample run: red text represents user input.

~/$ ./p3 [102 103 104 105 106 107 108 109 110 111 112 113 114 202 203 204 205 206 207 208 209 210 211 212 213 214 302 303 304 305 306 307 308 309 310 311 312 313 314 402 403 404 405 406 407 408 409 410 411 412 413 414] Player: [102 104] Dealer: [103 105] Round 1 Player's turn hit or stand ? [h/s] h Player: [102 104 106] Dealer: [103 105] Round 1 Dealer's turn hit or stand ? [h/s] s Player: [102 104 106] Dealer: [103 105] Round 2 Player's turn hit or stand ? [h/s] h Player: [102 104 106 107] Dealer: [103 105] Round 2 Dealer's turn hit or stand ? [h/s] s Player: [102 104 106 107] Dealer: [103 105] Round 3 Player's turn hit or stand ? [h/s] s Player: [102 104 106 107] Dealer: [103 105] Round 3 Dealer's turn hit or stand ? [h/s] h Player: [102 104 106 107] Dealer: [103 105 108]

~/$ ./p3 [102 103 104 105 106 107 108 109 110 111 112 113 114 202 203 204 205 206 207 208 209 210 211 212 213 214 302 303 304 305 306 307 308 309 310 311 312 313 314 402 403 404 405 406 407 408 409 410 411 412 413 414] Player: [102 104] Dealer: [103 105] Round 1 Player's turn hit or stand ? [h/s] s Player: [102 104] Dealer: [103 105] Round 1 Dealer's turn hit or stand ? [h/s] h Player: [102 104] Dealer: [103 105 106] Round 2 Player's turn hit or stand ? [h/s] h Player: [102 104 107] Dealer: [103 105 106] Round 2 Dealer's turn hit or stand ? [h/s] h Player: [102 104 107] Dealer: [103 105 106 108] Round 3 Player's turn hit or stand ? [h/s] h Player: [102 104 107 109] Dealer: [103 105 106 108] Round 3 Dealer's turn hit or stand ? [h/s] s Player: [102 104 107 109] Dealer: [103 105 106 108]

Part 4 [up to 55pts]: Shuffling the deck

Copy p3.cpp to p4.cpp.

Shuffle: [n | u <seed>]: u 103
[307 212 313 402 111 104 314 207 211 203 205 
303 204 202 206 405 214 410 304 108 308 213 
408 107 413 112 105 309 208 411 302 404 305 
312 113 114 414 109 106 110 407 103 209 311 
409 210 403 412 102 306 406 310]

Player: [307 313]
Dealer: [212 402]

Round 1 Player's turn
hit or stand ? [h/s] h

Player: [307 313 111]
Dealer: [212 402]

Round 1 Dealer's turn
hit or stand ? [h/s] h

Player: [307 313 111]
Dealer: [212 402 104]

Round 2 Player's turn
hit or stand ? [h/s] s

Player: [307 313 111]
Dealer: [212 402 104]

Round 2 Dealer's turn
hit or stand ? [h/s] h

Player: [307 313 111]
Dealer: [212 402 104 314]

Round 3 Player's turn
hit or stand ? [h/s] s

Player: [307 313 111]
Dealer: [212 402 104 314]

Round 3 Dealer's turn
hit or stand ? [h/s] h

Player: [307 313 111]
Dealer: [212 402 104 314 207]

In this part, we provide the program with the feature of shuffling the deck.

User input

When the program starts, the user is presented with message:

Shuffle: [n | u <seed>]:

If the user enters n, no shuffling will take place.
Otherwise, we'll shuffle using a random number generator, which of course needs to be seeded. In particular, if the user uses the u option followed by a number. This number is then used as the seed.

Shuffling the deck

If the user chooses to shuffle the deck, shuffling must be done exactly as follows:


for i from 0 up to 51 do    // so 52 times in total 
  set j to rand() % 52                                           
  swap the index i element of the deck with the index j element

(Note, this is not a good enough shuffling algorithm for "real" applications because it introduces a small amount of bias in the ordering, but this is what we're going to do to keep in simple.) See an example run on the right:

Part 5 [up to 70pts]: Pretty print

Copy p4.cpp to p5.cpp.

~/$ ./p2
Shuffle: [n | u <seed>]: u 103  

 Player Dealer
|  7♥  |  Q♦  |
|  K♥  |  2♠  |
Round 1 Player's turn
hit or stand? [h/s] h  

 Player Dealer
|  7♥  |  Q♦  |
|  K♥  |  2♠  |
|  J♣  |      |
Round 1 Dealer's turn
hit or stand? [h/s] h  

 Player Dealer
|  7♥  |  Q♦  |
|  K♥  |  2♠  |
|  J♣  |  4♣  |
Round 2 Player's turn
hit or stand? [h/s] s  

 Player Dealer
|  7♥  |  Q♦  |
|  K♥  |  2♠  |
|  J♣  |  4♣  |
Round 2 Dealer's turn
hit or stand? [h/s] h  
 
 Player Dealer
|  7♥  |  Q♦  |
|  K♥  |  2♠  |
|  J♣  |  4♣  |
|      |  A♥  |
Round 3 Player's turn
hit or stand? [h/s] s  

 Player Dealer
|  7♥  |  Q♦  |
|  K♥  |  2♠  |
|  J♣  |  4♣  |
|      |  A♥  |
Round 3 Dealer's turn
hit or stand? [h/s] h  

 Player Dealer
|  7♥  |  Q♦  |
|  K♥  |  2♠  |
|  J♣  |  4♣  |
|      |  A♥  |
|      |  7♦  |

Don't print the deck

From now on, we omit printing the deck.

Print the hands vertically

As shown in the sample run on the left, you must print the hands vertically.

Printing out face values

To print out the numbers neatly, make sure to use two spaces for a card's face value. For example, if the face value is 2, do as follows:


cout << " " << 2;  // we need " " because 2 takes only one space

On the other hand, if the face value is 10, do as follows:


cout << 10;        // we do not need " " because 10 takes two spaces

Printing out suits

Our Unix terminal program understands "UTF-8" character encodings, which means we can print card suits to the screen. Each suit symbol is represented by a string. Carefully look at the following code and its output. Adapt the code to your need.

source code output


string clubs = "\u2663";
string diamonds = "\u2666";
string hearts = "\u2665"; 
spades = "\u2660";

cout << 10 << clubs << endl;
cout << 10 << diamonds << endl;
cout << 10 << hearts << endl;
cout << 10 << spades << endl;

10♣
10♦
10♥
10♠

Part 6 [Up to 85 pts]: Best scores

Copy p5.cpp to p6.cpp. A correct part 6 solution should behave exactly like a correct part 5 solution except the following:

In each round the current "best scores" for both Player and Dealer hands should be shown. How the "best score" for a hand is computed is explained below.
The game continues until both Player and Dealer stand in consecutive turns. That is, Player stands then Dealer stands, or Dealer stands then Player stands. Therefore, the game may have more than 3 rounds. In fact, it may have less than 3 rounds as well.

Computing the best score for a hand

Add up points for each card in the hand as follows. Call this number total.
- Aces are worth 1 point
- Kings, queens and jacks are worth 10 points
- Numbered cards (i.e. 2 though 10) are worth their number in points.
Depending on whether the hand has aces or not, the best score is computed as follows:
- If the hand has no aces, "best score" for the hand is simply total.
  For example, the best score for Q♠ 9♥ is 10 + 9 = 19.
- However, if there are aces in the hand, compute the best scores as follows:
  - If the total is greater than 11, "best score" is simply total.
    For example, the total for 8♥ A♥ J♠ A♣ is 8 + 1 + 10 + 1 = 20. Since the total is greater than 11, the best score is 20.
  - Otherwise (i.e., if total is less than or equal to 11), the "best score" is total + 10.
    For example, the total for 7♥ A♥ is 7 + 1 = 8. Since the total is at most 11, the best score is 8+10 = 18.

Sample run: red text represents user input.

~/$ ./p3
Shuffle: [n | u <seed>]: u 92  

 Player Dealer 
|  Q♦  |  A♣ |
|  8♣  |  7♣ |
Player 18, Dealer 18
Round 1 Player's turn
hit or stand ? [h/s] h

 Player Dealer 
|  Q♦  |  A♣ |
|  8♣  |  7♣ |
|  6♠  |     |
Player 24, Dealer 18
Round 1 Dealer's turn
hit or stand ? [h/s] h

 Player Dealer 
|  Q♦  |  A♣ |
|  8♣  |  7♣ |
|  6♠  |  4♥ |
Player 24, Dealer 12
Round 2 Player's turn
hit or stand ? [h/s] h

 Player Dealer 
|  Q♦  |  A♣ |
|  8♣  |  7♣ |
|  6♠  |  4♥ |
|  2♣  |     |
Player 26, Dealer 12
Round 2 Dealer's turn
hit or stand ? [h/s] h

 Player Dealer 
|  Q♦  |  A♣ |
|  8♣  |  7♣ |
|  6♠  |  4♥ |
|  2♣  |  9♠ |
Player 26, Dealer 21
Round 3 Player's turn
hit or stand ? [h/s] h

 Player Dealer 
|  Q♦  |  A♣ |
|  8♣  |  7♣ |
|  6♠  |  4♥ |
|  2♣  |  9♠ |
| 10♠  |     |
Player 36, Dealer 21

Round 3 Dealer's turn
hit or stand ? [h/s] s

 Player Dealer 
|  Q♦  |  A♣ |
|  8♣  |  7♣ |
|  6♠  |  4♥ |
|  2♣  |  9♠ |
| 10♠  |     |
Player 36, Dealer 21
Round 4 Player's turn
hit or stand ? [h/s] h

 Player Dealer 
|  Q♦  |  A♣ |
|  8♣  |  7♣ |
|  6♠  |  4♥ |
|  2♣  |  9♠ |
| 10♠  |     |
|  Q♣  |     |
Player 46, Dealer 21
Round 4 Dealer's turn
hit or stand ? [h/s] s

 Player Dealer 
|  Q♦  |  A♣ |
|  8♣  |  7♣ |
|  6♠  |  4♥ |
|  2♣  |  9♠ |
| 10♠  |     |
|  Q♣  |     |
Player 46, Dealer 21
Round 5 Player's turn
hit or stand ? [h/s] s

 Player Dealer 
|  Q♦  |  A♣ |
|  8♣  |  7♣ |
|  6♠  |  4♥ |
|  2♣  |  9♠ |
| 10♠  |     |
|  Q♣  |     |
Player 46, Dealer 21

Part 7 [up to 100 pts]: Play!

Copy p6.cpp to p7.cpp. A part 7 solution functions just like a part 6 solution with the following two exceptions:

The Player and Dealer "best scores" are not printed out at any point.
The Dealer's top (first) card is only shown as ** until the end of the game. This way, the Player has some uncertainty about what to do.
Instead of being read in from the user, the dealer choice of whether to hit or stand is made by the program following the simple rule:
- The dealer always hits when his current "best score" is less than 17, and always stands otherwise.
Pause for dramatic effect after each time the dealer makes a decision. To do so, make the call sleep(1) (this will require #include <unistd.h>).
The game should continue until one of the following events takes place:
- The Player "busts", which means having a "best score" greater than 21.
- The Dealer busts.
- As in part 3, both Player and Dealer stand in consecutive turns. That is, Player stands then Dealer stands, or Dealer stands then Player stands.
When the game ends, we say there is a tie if both the Player and the Dealer have the same "best score". Now, depending on whether there is a tie or not, the program should do as follows:
- If there is a tie at the end, a new game is automatically played.
  Note:
  - Of course, a new deck should be created and reshuffled.
  - The random number generator is not reseeded; do not call srand again! You call srand once and for all in the beginning of the main function.
  - In other words, when the new game starts, as with part 1, you have to make an ordered deck and then shuffle it, but skipping the part of calling srand().
- If there is not a tie, the program reports who won with one of the following messages as appropriate:
  - Player busts, dealer wins
  - Dealer busts, player wins
  - Player wins
  - Dealer wins

Sample run: red text represents user input

~/$ ./p4
Shuffle: [n | u <seed>]: u 901  

 Player Dealer
|  Q♣  |  **  |
|  K♣  |  7♦  |

Round 1 Player's turn
hit or stand? [h/s] s  

 Player Dealer
|  Q♣  |  **  |
|  K♣  |  7♦  |

Round 1 Dealer's turn
hit or stand? [h/s] s  

 Player Dealer           
|  Q♣  |  A♦  |
|  K♣  |  7♦  |
Player wins

Sample run: red text represents user input

~/$ ./p4
Shuffle: [n | u <seed>]: u 500  

 Player Dealer
|  K♠  |  **  |
|  7♣  |  2♣  |
Round 1 Player's turn
hit or stand? [h/s] s  

 Player Dealer
|  K♠  |  **  |
|  7♣  |  2♣  |
Round 1 Dealer's turn
hit or stand? [h/s] h  

 Player Dealer
|  K♠  |  **  |
|  7♣  |  2♣  |
|      |  2♠  |

Round 2 Player's turn
hit or stand? [h/s] s  

 Player Dealer
|  K♠  |  **  |
|  7♣  |  2♣  |
|      |  2♠  |
Round 2 Dealer's turn
hit or stand? [h/s] h


 Player Dealer
|  K♠  |  **  |
|  7♣  |  2♣  |
|      |  2♠  |
|      |  3♦  |
Round 3 Player's turn
hit or stand? [h/s] s  

 Player Dealer
|  K♠  |  **  |
|  7♣  |  2♣  |
|      |  2♠  |
|      |  3♦  |
Round 3 Dealer's turn
hit or stand? [h/s] s  
      
 Player Dealer
|  K♠  |  Q♠  |
|  7♣  |  2♣  |
|      |  2♠  |
|      |  3♦  |

 Player Dealer
|  8♣  |  **  |
|  A♦  |  J♥  |
Round 1 Player's turn
hit or stand? [h/s] s


 Player Dealer
|  8♣  |  **  |
|  A♦  |  J♥  |
Round 1 Dealer's turn
hit or stand? [h/s] h  

 Player Dealer
|  8♣  |  **  |
|  A♦  |  J♥  |
|      |  A♥  |
Round 2 Player's turn
hit or stand? [h/s] h  

 Player Dealer
|  8♣  |  **  |
|  A♦  |  J♥  |
|  6♥  |  A♥  |
Round 2 Dealer's turn
hit or stand? [h/s] h  

 Player Dealer
|  8♣  |  5♦  |
|  A♦  |  J♥  |
|  6♥  |  A♥  |
|      | 10♣  |
Dealer busts, player wins

Extra Credit [+10pts]

The extra credit solution will not even be considered unless the Part 7 Full credit solution functions correctly.

Name your code px.cpp

When the game starts, the player will have $10 initially.
Your solution should play the game over and over again. Each time the player finishes a game, the program should ask whether the player wants to play again or quit. The game should end automatically when the player gets broke (does not have any more money).
In each play, the player must make a $4 bet. If the player wins, the player gets the bet plus $4 back. You must report how much the player has at the end of each game. If there is a tie, a new game should be automatically played without without printing any message at all, as in Part 7.
The player must have the option of withdrawing from a game (not the table, just that game) after the initial two cards are dealt to player and dealer, but before any other play has taken place. Withdrawing means half the bet is returned to the player, but the other half goes to the house.

~/$ ./px
Shuffle: [n | u <seed>]:  u 105

 Player Dealer 
|  5♣  |  ** |
|  4♦  |  7♠ |
Round 1 Player's turn
hit, stand or withdraw ? [h/s/w]  h

 Player Dealer 
|  5♣  |  ** |
|  4♦  |  7♠ |
| 10♥  |     |
Round 1 Dealer's turn
hit or stand ? [h/s] s

 Player Dealer 
|  5♣  |  ** |
|  4♦  |  7♠ |
| 10♥  |     |
Round 2 Player's turn
hit or stand? [h/s]  h

 Player Dealer 
|  5♣  |  K♣ |
|  4♦  |  7♠ |
| 10♥  |     |
|  5♥  |     |
Player busts, dealer wins
You have $6
Do you want to play again? [y/n]  y


 Player Dealer 
|  A♦  |  ** |
|  7♠  |  3♣ |
Round 1 Player's turn
hit, stand or withdraw ? [h/s/w]  w

 Player Dealer 
|  A♦  | 10♣ |
|  7♠  |  3♣ |
Player withdraws
You have $4
Do you want to play again? [y/n]  y

 Player Dealer 
|  K♠  |  ** |
|  3♠  |  J♠ |
Round 1 Player's turn
hit, stand or withdraw ? [h/s/w]  h

 Player Dealer 
|  K♠  |  5♣ |
|  3♠  |  J♠ |
|  Q♦  |     |
Player busts, dealer wins
You have $0
GAME OVER: Not enough money

~/$ ./px
Shuffle: [n | u <seed>]:  u 105

 Player Dealer 
|  5♣  |  ** |
|  4♦  |  7♠ |
Round 1 Player's turn
hit, stand or withdraw ? [h/s/w]  s

 Player Dealer 
|  5♣  |  ** |
|  4♦  |  7♠ |
Round 1 Dealer's turn
hit or stand ? [h/s] s

 Player Dealer 
|  5♣  |  K♣ |
|  4♦  |  7♠ |
Dealer wins
You have $6
Do you want to play again? [y/n]  n

Shuffle: [n | u <seed>]: u 500

 Player Dealer 
|  K♠  |  ** |
|  7♣  |  2♣ |
Round 1 Player's turn
hit, stand or withdraw ? [h/s/w] s

 Player Dealer 
|  K♠  |  ** |
|  7♣  |  2♣ |
Round 1 Dealer's turn
hit or stand ? [h/s] h

 Player Dealer 
|  K♠  |  ** |
|  7♣  |  2♣ |
|      |  2♠ |
Round 2 Player's turn
hit or stand? [h/s] s

 Player Dealer 
|  K♠  |  ** |
|  7♣  |  2♣ |
|      |  2♠ |
Round 2 Dealer's turn
hit or stand ? [h/s] h

 Player Dealer 
|  K♠  |  ** |
|  7♣  |  2♣ |
|      |  2♠ |
|      |  3♦ |
Round 3 Player's turn
hit or stand? [h/s] s

 Player Dealer 
|  K♠  |  ** |
|  7♣  |  2♣ |
|      |  2♠ |
|      |  3♦ |
Round 3 Dealer's turn
hit or stand ? [h/s] s

 Player Dealer 
|  K♠  |  Q♠ |
|  7♣  |  2♣ |
|      |  2♠ |
|      |  3♦ |

 Player Dealer 
|  8♣  |  ** |
|  A♦  |  J♥ |
Round 1 Player's turn
hit, stand or withdraw ? [h/s/w] h

 Player Dealer 
|  8♣  |  ** |
|  A♦  |  J♥ |
|  A♥  |     |
Round 1 Dealer's turn
hit or stand ? [h/s] h

 Player Dealer 
|  8♣  |  ** |
|  A♦  |  J♥ |
|  A♥  |  6♥ |
Round 2 Player's turn
hit or stand? [h/s] h

 Player Dealer 
|  8♣  |  ** |
|  A♦  |  J♥ |
|  A♥  |  6♥ |
| 10♣  |     |
Round 2 Dealer's turn
hit or stand ? [h/s] s

 Player Dealer 
|  8♣  |  ** |
|  A♦  |  J♥ |
|  A♥  |  6♥ |
| 10♣  |     |
Round 3 Player's turn
hit or stand? [h/s] h

 Player Dealer 
|  8♣  |  5♦ |
|  A♦  |  J♥ |
|  A♥  |  6♥ |
| 10♣  |     |
|  9♦  |     |
Player busts, dealer wins
You have $6
Do you want to play again? [y/n] n