• Deck of cards
• Basic Blackjack rules/logic
• Dealer
• Basic Dealer AI
• Player
• Controls for hit/stand
• Audio
• User Interface

In this first part of the series we are going to introduce the core of the game; the deck. We will be building a very generic deck of cards that could be used in any type of card game. The deck will be portable enough to just drag and drop into any project that requires a deck of cards. So, let’s begin by creating a view based application and calling it ICBBlackjack.

Creating A Card Object

Before we can create the deck, we need to create a card. Before we dig into the code, let me explain how a card object will work. A card has 2 properties that we care about. They are suit and value. Suit is pretty obvious (Hearts, Diamonds, Spades, Clubs), but the value might not be what you’d expect. For the cases of the numeric cards, the value is simply their value, however it changes a bit for the face cards and ace.

The Ace gets assigned a value of 1 (pretty obvious), while the face cards get values based on their ordering from the 10 card. So a Jack = 11, Queen = 12, and King = 13. Obviously this isn’t the case when playing a game like Blackjack, but we will let another class figure that out. For now, we will use the value as and identifier for the card. Add a new class file to your project called Card.m. Make sure you check the box to include the .h file. Open up Card.h and add the following code:

Card.h

typedef enum {
	Hearts,
	Diamonds,
	Spades,
	Clubs
} Suit;
 
#define Ace   1
#define Jack  11
#define Queen 12
#define King  13
 
@interface Card : NSObject {
	NSInteger value;
	Suit suit;
}
 
@property (nonatomic) NSInteger value;
@property (nonatomic) Suit suit;
 
- (id) initWithValue:(NSInteger) aValue suit:(Suit) aSuit;
 
@end

Ok, so a few things here to point out. The first thing we see at the top is an enum. The enum allows us to declare our own type called Suit. We could have just as easily used constants, but the enum makes things a little more clear. This allows us to do things like myCard.suit = Clubs.

Now, we define the “Special” values which will be assigned to the Ace and face cards. Finally, we declare our value and suit properties and declare and init method to build a card with these values set. Now, it’s time to implement our Card class. Open Card.m and add the following code.

Card.m

#import "Card.h"
 
@interface Card(Private)
 
- (NSString *) valueAsString;
- (NSString *) suitAsString;
 
@end
 
@implementation Card
 
@synthesize value,suit;
 
- (id) initWithValue:(NSInteger) aValue suit:(Suit) aSuit {
	if(self = [super init]) {
		self.value = aValue;
		self.suit = aSuit;
	}
	return self;
}
 
- (NSString *) valueAsString {
	switch (self.value) {
		case Ace:
			return @"Ace";
			break;
		case Jack:
			return @"Jack";
			break;
		case Queen:
			return @"Queen";
			break;
		case King:
			return @"King";
			break;
		default:
			return [NSString stringWithFormat:@"%d",self.value];
			break;
	}
}
 
- (NSString *) suitAsString {
	switch (self.suit) {
		case Hearts:
			return @"Hearts";
			break;
		case Diamonds:
			return @"Diamonds";
			break;
		case Spades:
			return @"Spades";
			break;
		case Clubs:
			return @"Clubs";
			break;
		default:
			return nil;
			break;
	}
}
 
- (NSString *) description {
	return [NSString stringWithFormat:@"%@ of %@",
			[self valueAsString],
			[self suitAsString]];
}
@end

Wow, so this looks like a lot of overkill. The truth is, you only need the init method that I created. The description method allows us to overwrite the printing method for a card and gives us pretty output. The other 2 methods are simply help methods for it (we have declared them as private at the top). You can choose to omit them if you like, but make debugging a lot easier. When you do something like NSLog(@”%@”,myCard), it will print “Ace of Spades”. Great, now you have a Card object to work with. Now we just need to create 52 of these puppies and we are on our way to hundreds of card games.

Creating The Deck

The deck of cards is fairly straight forward. First off, we need an array of cards. The card needs to have 3 methods implemented for correct functionality. They are draw, shuffle, and cardsRemaining. The reason the cardsRemaining method is needed is to prevent users from trying to draw cards from an empty deck (we will discuss this in a bit). Add a new class file to your project called Deck.m and add the following code to Deck.h:

Deck.h

#import "Card.h"
 
@interface Deck : NSObject {
 
@private
	NSMutableArray *cards;
}
 
- (void) shuffle;
- (Card *) draw;
- (NSInteger) cardsRemaining;
 
@end

A few things I want to point out. First, we import Card.h. Normally we would import the models in the .m file if they are not needed in the header. However, we need to declare the draw method which returns a Card object. So, we include the import statement here.

The next thing I want to point out is we have marked the cards array as private. We don’t want anyone mucking around in our deck without going through our methods. The reason for this is to prevent synchronization issues where someone modifies the deck without notifying the class. Kinda trivial, but good practice non the less. Now for the implementation. Add the following code to Deck.m.

Deck.m

#import "Deck.h"
 
@implementation Deck
 
- (id) init {
	if(self = [super init]) {
		cards = [[NSMutableArray alloc] init];
		for(int suit = 0; suit <= 3; suit++) {
			for(int value = 1; value <= 13; value++) {
				Card *card = [[Card alloc] initWithValue:value suit:suit];
				[cards addObject:card];
				[card release];
			}
		}
	}
	return self;
}
 
/*
 * Random sort used from this blog post
 * http://zaldzbugz.wordpress.com/2010/07/16/randomly-sort-nsarray/
 */
int randomSort(id obj1, id obj2, void *context ) {
	// returns random number -1 0 1
	return (arc4random()%3 - 1);
}
 
- (void) shuffle {
	for(int x = 0; x < 500; x++) {
		[cards sortUsingFunction:randomSort context:nil];
	}
}
 
- (Card *) draw {
 	if([self cardsRemaining] > 0) {
		Card *card = [[cards lastObject] retain];
		[cards removeLastObject];
		return [card autorelease];
	}
 
	NSException* myException = [NSException
		exceptionWithName:@"OutOfCardsException"
		reason:@"Tried to draw a card from a deck with 0 cards."
		userInfo:nil];
	@throw myException;
}
 
- (NSInteger) cardsRemaining {
	return [cards count];
}
 
- (NSString *) description {
	NSString *desc = [NSString stringWithFormat:@"Deck with %d cards\n",[self cardsRemaining]];
	for(int x = 0; x < [self cardsRemaining]; x++) {
		desc = [desc stringByAppendingFormat:@"%@\n",[[cards objectAtIndex:x] description]];
	}
	return desc;
}
 
- (void) dealloc {
	[cards release];
	[super dealloc];
}
 
@end

Ok, this file needs a little more explanation. First, we see the init method has been implemented. There are 2 for loops. The outer loop is from 0 to 3 representing the suit of each card. Basically, we want to create 13 cards for each of the 4 suits. The inner loop is from 1 to 13 representing the card’s value. We simply instantiate a Card object with the suit and value and add it to the cards array. Let’s chat about each of the methods.

Shuffle

The shuffle method simply sorts the array based on a random number. If we do it once, the deck will barely be shuffled, which makes sense. So, I have randomly sorted the array 500 times to ensure that it has been effectively shuffled. Note: I stole the randomSort method from http://zaldzbugz.wordpress.com/2010/07/16/randomly-sort-nsarray/ based on a quick/lazy Google search, but it’s a pretty common way of accomplishing this task.

Draw

We first check to see if the deck is empty. If it’s not, we retain the last object, remove it from the array and return an auto release of it. It will be up to the caller to retain the Card. Here is something you don’t see everyday, we are throwing an exception if the user tries to draw from an empty deck. Kind of a jerk move, but it will ensure that they check the cardsRemaining before performing a draw. Again, not totally necessary, but good practice.

cardsRemaining

Returns the length of the cards array I override the description method in this class to print out the deck in its entirety. Again, this is very useful for debugging. Finally, we rock the memory management and release our card deck array when our deck gets cleaned up.

Sample Run/Output

Here is a simple example of how to create a deck, shuffle, and draw.

        Deck *d = [[Deck alloc] init];
	NSLog(@"%@",d);
 
	[d shuffle];
	NSLog(@"%@",d);
 
	NSLog(@"Drew Card: %@",[d draw]);
	NSLog(@"Drew Card: %@",[d draw]);
	NSLog(@"Drew Card: %@",[d draw]);
	NSLog(@"Drew Card: %@",[d draw]);
 
	NSLog(@"%@",d);
 
	[d release];

The output is a little long, so I’ll just past some snippets of it. You can run this for yourself to see the full output.

Deck with 52 cards
Ace of Hearts
2 of Hearts
3 of Hearts
4 of Hearts
5 of Hearts
6 of Hearts
7 of Hearts
8 of Hearts
9 of Hearts
10 of Hearts
Jack of Hearts
Queen of Hearts
King of Hearts
Ace of Diamonds
2 of Diamonds
3 of Diamonds
...
(After shuffle)
Deck with 52 cards
King of Diamonds
6 of Hearts
5 of Spades
9 of Clubs
2 of Diamonds
8 of Clubs
7 of Hearts
Ace of Clubs
10 of Diamonds
Jack of Diamonds
8 of Spades
6 of Diamonds
Ace of Spades
3 of Spades
...
2010-09-07 14:56:37.953 ICBBlackJack[5465:207] Drew Card: Queen of Spades
2010-09-07 14:56:37.953 ICBBlackJack[5465:207] Drew Card: 9 of Spades
2010-09-07 14:56:37.954 ICBBlackJack[5465:207] Drew Card: 9 of Hearts
2010-09-07 14:56:37.955 ICBBlackJack[5465:207] Drew Card: Queen of Clubs

Deck with 48 cards
King of Diamonds
6 of Hearts
5 of Spades
9 of Clubs
2 of Diamonds
8 of Clubs
7 of Hearts
Ace of Clubs
10 of Diamonds
Jack of Diamonds
8 of Spades
6 of Diamonds
Ace of Spades

Note that drawing a card pulls from the end of the array. It doesn’t matter if you pull from the front or the back, just make sure it’s consistent.

Conclusion

Click Here To Download The Code For This Tutorial

And there you have it! A fully functional deck of cards. Please be sure to join me next time when we will start implementing the dealer and some basic Blackjack logic. Click Here To Download The Code For This Tutorial Feel free to post questions in the comments section or @reply them to me on Twitter.

The first part of this tutorial will discuss how to build the server. We will be doing this using PHP and MYSQL. I will also assume you have some working knowledge of PHP and MYSQL (if not, use the Google machine to get up to speed).

Since this tutorial is so long, I have decided to split it up into pages. You will notice the page number at the bottom. Please use them to navigate between parts of this post. I feel that I have to make this explicit as I will undoubtably get some dude in the comments saying “Where is the rest of the tutorial”.

Skill level: Advanced

Creating The Database

When creating a leaderboard, you will need some way of storing the data. We will be using MYSQL for our storage. You can also be lame and simply use flat files. This would add quite a bit of code in the long run as you would have to write all of the sorting and pagination functionality yourself. Don’t do it.

One thing to note about my php server files. I know they could be cleaned up a little and optimized (you could create a config.php that contains all the db interface code), but the goal of this tutorial is not to show you how to code killer PHP. It’s to show you how to create code that you can connect your iPhone apps to.

I like to create one file that does a complete flash of the database. That way, when I’m testing or switch from staging to production, it is a very simple process. So, with that being said, here is my code for create_db.php.

<?php
        // create_db.php
	/** MySQL database name */
	define('DB_NAME', '');
	/** MySQL database username */
	define('DB_USER', '');
	/** MySQL database password */
	define('DB_PASSWORD', '');
	/** MySQL hostname */
	define('DB_HOST', $_ENV{DATABASE_SERVER});
 
	$table = "highscores";
 
	// Initialization
	$conn = mysql_connect(DB_HOST,DB_USER,DB_PASSWORD);
	mysql_select_db(DB_NAME, $conn);
 
	// Error checking
	if(!$conn) {
		die('Could not connect ' . mysql_error());
	}
 
	// Drop existing table if exists
	mysql_query("DROP TABLE $table", $conn);
 
	$retval = mysql_query("CREATE TABLE $table(
		id INT(11) NOT NULL PRIMARY KEY AUTO_INCREMENT,
		udid VARCHAR(45),
		name VARCHAR(25),
		score FLOAT(10,2),
		date TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
	)",$conn);
 
	if($retval) {
		echo "Database created...";
	} else {
		echo "Could not create database " . mysql_error();
	}
 
	mysql_close($conn);
?>

I’m not going to go into too much detail about this code, however I will give a high level description of what’s going on. One thing to note about this code is it assumes you already have the database created.

First, we are defining variables that contain our database information. Make sure you replace my empty strings with your database info. After we connect to the database, we drop the table if it already exists. This is useful if you want to wipe out your test data. Finally, we create the scores table. Navigate to this file in your browser to run it and create the scores table. Pretty easy right?

You will want to make sure to remove this file from your server after running it to avoid people resetting your database.

Now that our database table has been created, it’s time to implement the web service code to publish new scores to our leaderboard.

If you have been on iCodeBlog before, you might recognize this “game” from a tutorial that I wrote about writing an iPhone game (link). One thing to note here is the company name is BlaBlaIncTech (not iCodeBlog) meaning I did not submit this nor did I give permission to do so. I find it interesting that someone has the guts to take a tutorial on iCodeBlog and submit it to the app store unmodified.

Not only was this VERY basic code meant to teach simple concepts, the graphics are absolutely atrocious as they were hacked together very quickly in Photoshop. I actually find this quite hilarious that this guys expects me not to find out.

I wanted to highlight some of the great features noted by the “developer” of this application (Seen in the feature section of iTunes).

• “It’s basic game design makes it a fun game for someone that doesn’t play alot of games” – WOW, emphasis on the BASIC. This game is fun for no one as it sucks! It was meant as a teaching tool moron!
• “Great Quality” – Are we looking at the same game?
• “Easy (So easy your grandma can play)” – If you have the same taste in games as your grandma, you probably don’t own an iPhone.
• “Almost no crashes” – hahahaha this is the best one. The keyword here is “Almost”. Well, that does it, I’m sold!

So, if you want to scoop up this rad game, the link is here . I almost will pay him the $.99, just to make fun of him in the comments section.