Project - Baccarat - Macao
Goal
The goal of this program is to produce a text-based Baccarat game. If you are unfamiliar with Baccarat (and its variant Macao), the general premise is as follows: Players attempt to obtain a higher hand value than the banker by adding the values of cards and taking the last digit of the result. Bets are made and can be increased based on how the player wins. The rules and their details will be clarified below. More information can be found here: https://en.wikipedia.org/wiki/Baccarat_(card_game)#Macao

Your game should handle a minimum of one player against the banker. The player will start with an initial chip count and place a bet before each hand is played. Players can play as many hands as they like until they run out of money or choose to quit. When the player quits, the total amount of chips won will be displayed along with a farewell message.
Pair Programming
During this project, you will each work in pairs. Pair programming is a development technique that can often lead to better results and understanding of programming challenges. More details can be found here: https://en.wikipedia.org/wiki/Pair_programming.

Setup
Create a Netbeans project similar to how you did so in previous projects. Name it using the following convention: Last1Last2_Project_Baccarat where Last1 and Last2 are the partner’s respective last names.

Additionally, please place this header in all of your java source files:

/* PROGRAMMERS:
 * CLASS: AP Computer Science
 * ASSIGNMENT:
 *
 * CERTIFICATION: We certify that this work is our own and that
 *                none of it is the work of any other group.
 */

Specification
Use the following steps to guide your program development. Pay attention to data types and the necessary arithmetic operations, conditional statements, loops, and more. Test your programs thoroughly! This means trying a variety of input values within the possible ranges described below.

The Following descriptions are intentionally less explicit in details than previous projects. You will not see “The instance variables are…” Your team must read the specification and come up with things like appropriate instance variables, constants, and method implementation details. This is the design process and allows for flexibility in creating your program.

There will be multiple classes and enumerations in this program: Suit, Rank, Card, Hand, Deck, Shoe, Banker, Punter, and Baccarat. Each class is described below. Required methods are explained, but you can (and probably should) make other helper methods. How this is done is up to you, but you should aim to minimize code redundancy and keep your classes readable.

NOTE: Do NOT assume that the described methods and variables are the only things needed to complete the program.
NOTE: Just because a method exists does NOT mean you must use it.

Enumeration: Suit
Create an Enumeration representing the possible suits cards may be: clubs, diamonds, hearts, or spades.
Enumeration: Rank
Create an Enumeration representing the possible values cards may be: 2 - 10, Jack, Queen, King, or Ace.
Class: Card
Represents a single card in a deck of cards.

Every Card has a Suit and Rank.
Create accessors for the suit and rank
Create a constructor that accepts a Suit and Rank.
Create a toString method.
Cards can be represented by two characters: their rank and their suit.
Ace of Spades ⇒ AS
Four of Diamonds ⇒ 4D
Jack of Clubs ⇒ JC
Return the String representation of the Card.
Class: Hand
Represents a single Baccarat Hand. May contain 0 or more cards.
Every Hand has a list of Cards.
Create a default constructor that creates an empty list.
Create an addCard method
Accepts a Card and stores it in the list.
Create a getCard method
Accepts an index and returns the card at that index in the list of Cards.
Create a calculateScore method.
Returns the numeric score of the cards in the hand.
Numeric cards are worth their face value (2 of hearts ⇒ 2), except 10s.
Face cards and 10s are worth 0.
Aces are worth 1.
Scores are calculated by summing the values of individual cards and taking the rightmost digit of the total.
Examples
5H 5D 7D ⇒ 7
JD KD ⇒ 0
AD AS 10H 2S ⇒ 4
9H KD ⇒ 9
Create a toString method.
Return a String representation of the Hand.
Each card should be displayed with a space between them.
Examples:
AH 8H
7D JS 4C


Class: Deck
Represents a single deck of playing cards with 4 suits, each having 13 cards ranking from 2 - 10, Jack, Queen, King, and Ace totalling 52 cards.

A Deck contains a list of Cards.
Create a constructor that accepts a boolean value that represents whether or not to shuffle the deck when created. The constructor should load the list with all 52 cards. If the boolean given is true, shuffle the deck, otherwise leave them in the order created.
Consider using the values method available to all Enumerations.
Values() returns an array containing all the values in the Enumeration and can be used in a loop.
Create a shuffle method.
Shuffle the cards in the deck randomly. Use the Fisher-Yates Shuffle algorithm described in the following pseudo-code. For more information on this shuffle, visit https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle.

-- To shuffle an array a of n elements (indices 0..n-1):
        for i from n−1 downto 1 do
             j ← random integer such that 0 ≤ j ≤ i
             exchange a[j] and a[i]

Create a getCard method.
Returns a single Card from the deck.
The card returned should no longer be in the deck after the method is called.
Create an isEmpty method.
Returns true if there are no more cards left in the deck, and false otherwise.
Create a toString method.
Returns a String representation of the Deck. Every card should be seen.
Class: Shoe
Represents a card dealing shoe. This will hold two decks for the game, but should be able to hold any number of decks.

A Shoe should be able to hold any number of card Decks, but should load them into one collection. Imagine this as a “super deck” where all cards from added Decks are together.
Create a constructor that creates an empty Shoe, i.e. one containing no Cards.
Create an addDeck method that accepts a Deck of cards and adds the cards of this new deck into the Shoe.
Mirroring the Deck class, create a shuffle method following the Fisher-Yates Shuffle algorithm. https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle.
Create a deal method that returns the next available card from the shoe. The dealt card should no longer be in the Shoe after the deal method is called.
Create a method needsShuffle that returns true if less than 25% of the original number of cards is left in the Shoe.

Class: Punter
Represents a single human player in the game of Baccarat.

Every Punter has a Hand and some whole number of chips. Punters gain and lose chips by playing rounds of Baccarat.
Create a constructor that accepts an initial amount of chips for the Punter.
Create a setHand method.
Accepts a Hand and stores it as the Punter’s hand.
Create an addCard method.
Accepts a single Card to add to the Punter Hand.
Create an accessor to get the number of chips the Punter has.
Create an adjustChips method.
Accepts a number to adjust the chip total by. This may be a positive or negative whole number.
Create a getHandScore method.
Returns the value of the Punter’s hand based on the cards they have.
Create a getCurrentHand method.
Return a String representing the Punter’s current Hand.


Class: Banker
Represents the Baccarat Banker, which is run by the computer. The banker controls the shoe that contains the decks of cards and has a hand that is challenged by the human players.

The banker has a Hand just like the player but also has a Shoe of cards.
Create a default constructor that creates a new Shoe. It must be shuffled before dealing any cards.
Create a shuffle method.
Shuffles the cards in the Shoe.
Create a hasUseableShoe method.
Returns true if the Shoe the Banker has does not need to be shuffled.
Create a dealCard method.
Returns a single card from the Shoe.
Create a dealInitialHand method.
Returns a new Hand with two Cards from the Shoe.
Create a setHand method.
Accepts a Hand and stores it as the banker’s Hand.
Create an addCard method.
Accepts a single Card to add to the banker Hand.
Create a getHandScore method.
Returns the value of the banker’s hand based on the cards they have.
Create a getCurrentHand method.
Returns a String representing the banker’s current Hand.
Create a getIncompleteHand method.
Returns a String representing the banker’s initial Hand, but only shows the first card.
This method can assume there are only two cards in the current hand.


Class: Baccarat
This class represents the entire game of Baccarat and has the main method that starts the program. It will use all previously created classes to produce a functioning game of Baccarat.

NOTE: When asking for numeric input from the user, you MUST validate that given values are within any necessary and appropriate ranges, e.g. chip count, number of decks, etc.

The flow the Game is as follows:
Welcome the users to the game.
Ask how many humans (Punters) will be playing the game. Each Punter plays against the banker individually and may leave after any hand.
Ask for the desired number of card decks to be placed in the shoe.
There must be a minimum of 2 decks.
Shuffle the contents of the shoe.
For Each Punter do the following:
Ask the Punter for his or her bet.
The bet must be valid.
If the Shoe has less than 25% of its cards left, let the Punter know with a message and then rebuild the Shoe with a new set of Decks, and finally shuffle it once again.
Deal two cards to the Punter and then deal two cards to the Banker.
When displaying the Banker’s hand only show one of the two cards. As in a physical game, one card would be face down and unknown to the Punter. Show both Punter’s cards.
Ask the Punter if they wish to add another card.
The punter aims to beat the banker’s card value. If not, the bet is lost to the banker.
Hand values are determined by adding the cards in the hand, and taking the last digit of the sum. Numeric cards, except tens, are worth their value; tens and face cards are worth zero; Aces are worth one.
Example: a hand with a 2 and 3 is valued at 5, while a hand with a 2, 4, and 7 is valued at 3.
Once the Punter does not want any other cards or has reached the limit of 6 cards in their hand, the Banker will display its current hand and the winner will be decided. The winner has a higher Hand value.
If there is a tie, the player with the fewest cards wins.
If there is a tie and players have the same number of cards, the banker wins.
If a Punter has a “natural” 9 (meaning the first two cards value at 9), they win triple the bet, unless the banker also has a natural 9.
If a punter has a natural 8, they win double the bet, unless the banker has a natural 8 or higher score.
If a Punter wins with a 7 or lower, only the initial bet is won.
Adjust the Punter’s chip count accordingly and ask if they wish to play again.
If the Punter has no more chips, end the game for that Punter with a message disparaging their lack of Baccarat-playing abilities.
Repeat this process of each Punter playing the game.
Repeat steps a to g until all Punters still playing have finished.
If the Punter has a higher chip count than they started with, leave them with a message congratulating his or her success.
If the Punter has broken even or ended with fewer chips than started with, leave them with a message that neither praises them nor overly disparages them.
Finally, display all players and their total chip count in order of most chips to fewest and The percentage of wins for each player and the banker.
Example: There were 2 punters. Each played 10 hands against the banker. Player 1 won 5 out of 10 hands. Player 2 won 3 out of 10 hands. This means the dealer won 12 out of 20 hands. So the stats would be:
Banker - 12/20 = 60% wins
Player 1 - 5/10 = 50% wins
Player 2 - 3 / 10 = 30% wins