Difference between revisions of "Matlab Blackjack Report"
|Line 26:||Line 26:|
== Appendices ==
== Appendices ==
Revision as of 15:41, 14 December 2012
Table of Contents
Blackjack is one of the most popular card games in the world with relatively simple rules. The player must try to beat the dealer by having a higher score without going over 21 points. In this project, are goal was to recreate a blackjack simulator. First we read about the casino rules for blackjack where the player is against the dealer. Next, we planned out our project by thinking of what programs we would need to make and implement. After we had written all the programs, we did many test and added more lines of code to make sure that everything was working properly.
Our main goal for this final project was to create an accurate Blackjack simulator. Understanding how to efficiently and effectively use Matlab was often frustrating through the year, so we wanted to use this final project as a way to get extra practice with the program. We wanted to better understand coding techniques and thought making a game like blackjack would be a fun way to do so. Since blackjack is a betting game, we thought it would be interesting to create a simulator where we can bet chips instead.
Extended Rules of Blackjack
As briefly mentioned, in order to win blackjack against a dealer, the player must have more points than the dealer without going over 21 points. The player and dealer are both felt two cards but only one of the dealer's is faced up initially. Cards are worth their number value with jacks through kings also being ten points and aces can be eleven or one points depending on which works better. First, it it the player's turn and the user can decide to hit (get another card) or stand (end their turn). If the player goes over 21 points, he/she busts and automatically loses. Otherwise, it will then be the dealer's turn who will flip over his second card and must continue to hit until he either busts or has 17 points or greater. If neither the player or dealer bust, then the winner is the person with more points and that person will win the bet. It the player gets a blackjack, which is a ten-value card along with an ace, the player automatically wins 1.5 times his bet. If the player and dealer tie a round, then the bet is split and nobody loses or gains money.
After fully understanding the rules of blackjack, it immediately became clear than many if statements and while loops were going to be needed. If and else if statement will only execute if specific conditions are met, otherwise the program will skip that portion of the code. This is important because, for example, we would want the round to end right away if the player goes over 21 points because there would be no use in having the dealer go though his turn if that condition is met. While loops are indefinite loops that will continue to execute until certain conditions are changed. These were also important to the coding progress because, for example, when we ask the user to input a bet, a while loop will continue to ask the user for a valid bet until the bet is greater than the minimum bet but less than the total number of chips the player has.
Completed Project Design
From the outermost level, the blackjack simulator we created is one giant while loop. The conditions for the while loop to end are if the user does not have enough chips to make the minimum bet, has over 1,000,000 chips, or if the user types in 0 for the bet. Each run through the while loop will execute one individual round of black jack. before this main while loop, the program will call an intro function which will inform the player about the rules for playing and will identify how many chips the player starts with. The first function inside the loop is a 'getbet' function. This function contains a while loop to ensure that the player inputs an appropriate bet. Next, the main code will call a 'getcard' function which will randomly choose a number between 1 and 52 and assign a card suit and number to that number. Next is the 'getvlaue' function which will convert a card into a point value so it can be tallied up. Once the player has two cards and the dealer has his one face-up card, the code runs through another while loop that will give the player another card until they stop inputting 'h' for hit. Each run through this loop will deal one more card and add up the player's total point value to make sure the player doesn't bust. If the player goes over 21, if statements are used to check if any of the cards were an ace, so that its value could be reassigned from an 11 to a 1. Using another if statement, if the user ends his or her turn without busting, then the dealer will receive his second card and goes through a similar while loop himself. The dealer must continue to hit and add to his total point value until he bust or has more than 17. Once again, if statements are used to check if an ace can be reassigned to a 1 if the dealer busts. If neither the player or dealer bust, then some final if and elseif statements are used to check if the dealer or player had more points and reassigns the chip total appropriately. Before the end of each run through the main while loop, a 'getwinloss' function is called which determines if the player has enough chips to continue playing or not. If the player has enough, the program will start another round of blackjack by returning to the beginning of this outermost loop. If not, the game will print a game over message and the program terminates.
See links at bottom of page to see the actual code with clear comments.
As a whole, we were happy with the result of our blackjack simulator. We reached our goal of creating a blackjack game using Matlab and we were able to allow betting. All of the while loops worked well and the game continue to play smoothly until the user runs out of chips or types a '0' to exit. All of the betting seemed to work especially well. The program can accurately decide who wins each round and the total chips that the player has gets reassigned based on the result and how much was betted. Despite our successes, we realize that the simulator is not perfect. We could not get our 'getcard' function to work exactly how we wanted to. The function returns a random card found with a number between 1 and 52 every time it's called. This means that the function could potentially return the exact same card many times in a row. In normal blackjack, of you are felt and ace, it would be slightly less likely for your next card to also be an ace, but in our simulator the probability doesn't change. Also, with the time constraints, we were unable to add functions for double down or for splitting which are additionally rules for blackjack that are allowed at many casinos. However, we did successfully implement the standard rules of blackjack.
When writing the blackjack simulator we had to stay organized and properly use the different programming techniques we have learned. Are implementation of while loops and if statements worked well, but when glancing at the code, everything looks jumbled and messy since there are multiple layers of loops and if/else statements. Maybe it would be better if we managed to make the code easier to look at. Also we found out that we had to be careful with variable names and stay consistent throughout. When we were debugging the program, we wasted a lot of time trying to find simple errors such as typing in variable names incorrectly. If we were to continue with this blackjack simulator, we would fix the 'get card' function so that once a card is chosen it would be removed from the deck and couldn't be chosen again. Some extensions we could make would be adding the options for double down and splitting, or allowing the player to to play multiple hands against the dealer at a time.
The code for the blackjack simulator and the functions can be found in this zip file. All of the code has comments. File:MATLABBLACKJACK.zip