Blackjack Summary
How it all began
May 08, 2020 Article Summary X. The best time to split pairs in blackjack is when you're dealt 2 aces or 2 eights, which will increase your chances of getting 21. You should also split a pair of twos, threes, or sevens if the dealer shows a seven or lower. If the dealer shows a two through six, split a pair of sixes. On many blackjack websites you will find a brief summary of the MIT team, and most of those summaries are just a recap of the movie. Counting Edge is about to take you behind all of the hype and beyond all of the glitz and glamour to reveal the accurate story of the whiz kids who became legendary card counters. Feb 05, 2021 However, this summary is not a replacement for fully complying with the terms of EO 157, EO 192, and any and all additional requirements imposed by the Division of Gaming Enforcement, including Casino Association of New Jersey protocols. Casinos should read the full guidance carefully to ensure full compliance. Reopening protocols at casinos. Jun 10, 2016 Ronald Koltnow rated it liked it This is the eighth adventure of Robert B. Parker's laconic lawmen Virgil Cole and Everett Hitch, and the fourth written by Robert Knott. Like its predecessors, it is mind candy, all fluff and sugar, and a fun way to spend a couple of hours.
The origin of Blackjack history is one of the most debatable points in the history of all gambling games. Some say the game traces its roots to back to the French game 'vingt-et-un' (21), which was popular in French casinos in the 17th century. Others believe the history of blackjack started from Italy, as an Italian game 'Thirty one' appeared a lot earlier, in the 13th century. Let's find out all about these games.
Blackjack Evolution
The Game of Thirty One
The Italian game Thirty one was first mentioned in the XIV century.
The aim of the game was to get a hand totaling 31.
The Italian game 'Thirty One' has lots of similarities with the current game of blackjack, though the aim of it was to get a hand totaling 31 from 3 cards. The fact the game appeared in the XIV century makes this game the first predecessor of blackjack as we know it today. The first time this game was mentioned was in an anti-gaming sermon by an Italian monk - St. Bernardine of Siena. This sermon led to public burnings of dice, cards and backgammon boards. This sermon dates back to 1440.
Fun Fact: The first deck of cards was printed by Johan Guttenberg, also famous for printing the first Bibles. The deck had 22 trumps and 4 suits of 14 cards. Each suit had 10 numbered cards, a King, a Queen, a Knight and a Valet (Jester).
The game 'Thirty One' was also mentioned in the classic and famous work by Francois Rabelais - 'Gargantua and Pantagruel'. The game was listed in Chapter XXII as one of the 100 games played by Gargantua: '… Then the carpet being spread, they brought plenty of cards, many dice, with great store and abundance of chequers and chessboards. There he played at flush, primero, the beast, trump…one-and-thirty…..'. The reference dates back to between 1532 and 1542.
The game was then mentioned in one of the stories of the famous Spanish writer - Miguel de Cervantes, where he described a great blackjack, or 'Trentuno', cheat. The story was called 'Riconete and Cortadillo' and was published in 1613, which is over 150 years later than the first mention of 31 in Bernardine's sermon.
Seven and a Half
Seven and Half was very popular in Italy and brought lots of its features to modern blackjack.
Unlike in modern blackjack, the dealer could choose what to do in the game.
Another Italian game of the 17th century brought lots of features that make blackjack today the way we know and love it.
The Italian game 'Seven and a Half' was very popular entertainment pastime with some similarities with the game of blackjack you will definitely notice. According to the rules of the game, it was played with only 8's, 9's, 10's and face cards. The values of cards were the following: Aces were counted as 1; Face cards all counted as a ½ and all the rest cards were counted according their values. The King of diamonds in the game was considered as a wild card. Any player that received a total higher than 7.5 would automatically go bust. The player who got a value of 7 ½ won and was paid more than even money. The dealer unlike in modern blackjack, was allowed to hit and stand when he wanted.
French Vingt-et-un
The game Vingt-et-un differed in many aspects from the game blackjack as we know it today, though there are still many common features. The cards in this game were dealt in rounds allowing players to bet on each of the rounds. Though the aim of the game was partly the same - to get a hand of 21, the game was different as only dealer could double and if he got a Natural, all the players would pay him triple. Player's Natural paid double and a busted hand was an automatic loser. In Vingt-et-un the Ace could be 1 or 11 which has carried on to the modern game
As you can see, the game of Vingt-et-un is similar to blackjack game, therefore it is mostly considered to be the true predecessor of modern Blackjack.
Vingt-et-un more than any other game is similar to modern blackjack.
The game was loved by the French elite and was even played by the mistress of the king Louis XV.
Fun fact: Vingt-et-un was very popular among French and even the mistress of Louis XV, Madame du Barry loved this game so much she made the king organize 'Vingt-et-un' parties to make her happy. Another interesting fact is that Napoleon, who was against card games as they distracted his soldiers, played Vingt-et-un daily on his exile on Elba to kill time.
All in All
All things considered, there are no hard facts and no one can say for sure what the origin of blackjack is. Some researchers believe this game has derived from other similar French game , however those games are based on accurate and well-balanced calculations. Also the fact that casino games very rarely mutate into other games is a strong argument that blackjack did not come from vingt-et-un or any other game.
Still, there are such scholars that think blackjack belongs to the family of games that includes Baccarat, Seven-And-A-Half and Vingt-et-Un, 21 and Pontoon. These games may be very familiar to you, and as there are lots of common features they all are considered to be the ancestors of modern blackjack.
Blackjack in America
When the game of 21 came to America it started a new era and soon became the most popular gambling game.
From its origins in Europe, blackjack has spread out throughout the world and came to America after the French Revolution in 1789. The game became hugely popular after casino owners offered amazing bonuses (for a hand of Jack and Ace of Spades the player got a 10 to 1 payout which brings us to the origin of the name of Blackjack).
The first name for the game however was Twenty-One which has been used in New Orleans since 1823.
As in Europe the game of blackjack was mainly a game of entertainment, then professional gamblers in the USA tried to make it a source of gain by manipulating gaming odds and varying bets. There were no specific governmental regulations for the gambling industry and that is why the game developed quickly and became more and more popular. It continued like this until the 19th century when the government of the US found out how gambling, influenced corruption and led to organized crime.
According to many researchers, the modern history of the game of blackjack started with the Nevada Gambling Act of 1931 that legalized gambling in all Nevada casinos.
This led to many changes for blackjack history. As most of US states criminalised gambling, Las Vegas in Nevada attracted gamblers from all over the world to its casinos, and blackjack became one of the most popular games at all casinos. The interest in the game grew and was boosted with the book by Edward Thorp 'Beat the dealer', and you can read about it in the History of card counting.
Modern Blackjack
The first green-felted table was made in 1919 and the game was the third most popular after Roulette and Craps in 1931. In the next 15 years blackjack overtook Roulette to become the second most popular game, after Craps. The first variant of blackjack basic strategy appeared in 1958, around the same time as card counting (1949 - first version, though the first blackjack basic strategy that gave the odds appeared in 1962 according to the history of card counting) as blackjack became the most popular gambling game. Nowadays each and every online and land casino has not only traditional but several more blackjack variations.
The game of blackjack is mostly played online nowadays allowing millions of players from all over the world to play this well-adored game even if the nearest casino is hundreds of miles away. Online blackjack has all the features of a land casino game and can offer players a lot more options. However, online blackjack leaves no chance for card counters as it is impossible to track the cards whilst playing online.
History of Blackjack - Summary
1440
First mentioning of a game Trentuno in a sermon by St. Bernardine of Siena.
1532 - 1542
Francois Rabelais mentioned the game one and thirty in 'Gargantua and Pantagruel'.
1613
The game was mentioned in a story by Miguel de Cervantes 'Riconete and Cortadillo'.
XVII beginning
The beginning of the XVII century brought us two games Seven and Half and Vingt-et-un, both believed to be predecessors of blackjack.
1789
After the French Revolution, the game came to America.
1931
Nevada Gaming Act legalized gambling in Nevada.
1958
Blackjack Basic Strategy appeared in its first form.
TOP 3 US blackjack casinos
Welcome back to our Deep Dive series on building the casino game Blackjack in C# and Blazor WebAssembly!
In this second part, we're going to use the modeling ideas we wrote down in the previous post to build a complete C# model for a Blackjack game.
You might want to read the previous post in this series before reading this one. Here it is:
Also, there's a sample GitHub repository that has all of the code used in this series.
All caught up? Good! Let's jump right in.
Basic Enumerations
Let's begin our C# modeling with the most basic type we can model: enumerations for the card's suit and value.
We will deal with the score later in this post.
Playing Cards
The next-most-simple object we can model is the individual playing cards. You may recall from the previous post that we decided that the Card object should have the following attributes:
- A suit
- A value
- A score
Suits and values are already defined as enumerations, and by making them properties of the Card object we can calculate a score.
Visibility
We need to consider one additional situation for this model, and that is this: the dealer has one card that is not visible to the player. So what model should that property (visibility) be a part of?
There are several ways to answer this question; the one we are going with is that we will make a new property IsVisible on the Card object. This property will be settable outside of the object so that the Dealer can mark their cards as not visible.
IsTenCard
Lastly, and as a convenience, we can define the property IsTenCard to identify if the given Card instance is a Ten, Jack, Queen, or King, and thus worth ten points.
Image URLs
We are implementing the display for our cards as individual images, with names like cardClubsJack.png, cardHeartsSix.png, cardSpadesAce.png, etc.
The images look like this:
Our Card object will need a property which stores the name of the image to display for that Card.
The Deck
The next object we can build is the deck of cards.
A Collection of Cards
The deck, at its core, is very simple: it's a collection of Card objects. But what kind of collection?
One of the properties of a real-world deck of cards is that, when drawing a card, we always draw from the top of the deck. There is a collection class in .NET that implements similar functionality: the Stack<T> class. Stack<T> defines a Pop() method, which removes and returns the 'topmost' object in the collection.
Our new CardDeck object will need a property of type Stack<Card> which stores the individual Card objects.
Count, Add, and Draw
We must now consider a few properties. First, we need to keep track of how many cards remain in the deck; if the number of cards gets below a certain value, we need to reshuffle the deck.
As we decided in the previous post, we need methods to add cards to the deck and to draw a card from the deck. These methods are fairly straightforward to implement:
Initialization and Shuffling
The most complex part of the CardDeck implementation is this: when we create a new instance of CardDeck, we need to first populate the cards with the correct number and suits, and then shuffle the cards thoroughly.
Let's start by creating a constructor for our CardDeck object, which first creates and inserts all of the cards needed.
We now need to extend this constructor to shuffle the cards. For this, we'll be using the venerable Fisher-Yates Shuffling Algorithm I blogged about a while back:
Here's that implementation:
Our CardDeck object is now ready for use! We can move on to the more-complex objects, starting with Person.
The Person Object
Recall from the last post that we need a common Person object that both Player and Dealer will inherit from. That Person needs the following abilities:
- Keep a hand of cards
- Use the hand to calculate a score
- Use the hand to determine if they are busted
The Visible Score Problem
First, though, we need to solve an unsolved problem from the previous post: how do we deal with the Dealer object's visible score (e.g. the score from only the face-up cards)?
This is one of those places where the modeler (i.e. us) can make 'executive decisions'. There are a couple of ways to model the visible score, such as making it a property of the Dealer object, a property of the Person object, or an external method. For this post, I have chosen the second option: we will make a property VisibleScore that is part of the root Person object, since it is Person that holds the property for Cards. Please note that none of these options are inherently worse than the others, they just require different implementation details.
With all that in mind, we can build a Person object with a set of properties to represent those abilities. Here's the skeleton object:
We now need to fill in the other properties.
True Scores and Visible Scores
The most complex thing the Person object will do is calculate that person's current score. Because we want a property for the VisibleScore and a property Score for the true score, we will use a private method to calculate the score.
The algorithm to calculate the score goes like this:
Operation Blackjack Summary
- PASS IN a value that determines whether we calculate the visible score only, or the true score.
- IF the sum value of all cards is less than or equal to 21, return that sum.
- IF there are no Aces in the person's hand AND the sum is greater than 21, the person has bust, so return the score.
- IF there are Aces in the person's hand...
- WHILE there are Aces left that have not been converted
- CONVERT a single Ace to being worth 1 point.
- IF the score is now less than or equal to 21, return the score.
- END WHILE
- IF the score is STILL greater than 21, the person has bust, so return the score.
The resulting code looks something like this:
We can then make two properties; one for the true score, and one for the visible score.
Checking for Blackjack and Bust
In the previous post, we decided that we wanted a special display that normally displays the Person's score, but will also show when they get a blackjack and when they bust.
To do this, we first need a property that checks to see if the Person has a blackjack. A person has a blackjack if;
- Their score is exactly 21 AND
- They have exactly two cards AND
- One of their cards is an Ace AND
- The other card is a ten-card
Here's the property for this:
We also want a convenience property that shows if the Person has bust:
The Score Display
Using the properties HasNaturalBlackjack and IsBusted that we just defined, we can now create a property to display the Person object's score. This property uses all of the properties of Person that we have defined so far:
Convenience Methods - Adding a Card and Clearing the Hand
There are two convenience methods we still need, though your implementation may forego them.
First we need a straightforward method to add cards to the Person's hand:
Finally, we need a method to clear the Person's hand:
With all of that, our root Person object is complete! Now we can move on to the Dealer and Player objects.
The Dealer Object
Let's start with the Dealer object.
The Dealer needs to inherit from the root Person object:
From there, we can add the properties unique to the Dealer
The Card Deck
Let's start with a property for the CardDeck object:
Dealing
The Dealer object will also need three methods:
- A method that draws a card from the deck.
- A method that draws a card from the deck to give to the player.
- A method that draws a card from the deck to give to the dealer.
These methods end up being pretty straightforward:
Has an Ace Showing
We also need one convenience property that is used for the Insurance special play: whether or not the Dealer has an Ace showing.
Blackjack Strategy Summary
With that, our Dealer is complete, and we can move on to implementing the Player object.
The Player Object
The Player object, like the Dealer, needs to inherit from Person.
Funds
The most distinguishing characteristic of the Player is that they have funds, i.e. the money they walked up to the table with. Let's create a property for those funds, and set an initial amount:
Bets
We also need properties to keep track of the Player's bets: their main bet they make before each hand, and the optional Insurance bet.
We will also want a convenience property to show whether or not the Player has made an insurance bet:
The Change Amount
After each hand, the player's funds may change based on whether they won or lost the bet. Let's write a property that keeps track of this change amount.
Has Stood
We need a convenience property to show whether or not the player has decided to stand:
Payouts
Blackjack Rules Summary
Finally, we need a method for the player to adjust their Funds property based on whether they won or lost the bet after each hand.
Now our Player object is complete and ready to gamble his/her chips!
Summary
21 Blackjack Summary
Phew! That was a lot of work. But now our implementation of Blackjack in C# is ready to go, and we can start building the Blazor components which will make up the display area of the game.
We can now build components for:
- The Player and Dealer hands
- The Player and Dealer scores (visible and total)
- The Player's funds and how they change after each hand
- The current bet
- The status of the Player (e.g. whether or not they have stood) AND
- The result of the hand (e.g. whether the Player wins or loses)
Implementing these components and more is exactly what we will do in the next part of this series. Stick around!
Do you have a way you can improve on my design? Submit a pull request or let me know in the comments! I am always looking for input from my dear readers.
Happy Coding!