This is the code for a blackjack game that deciacco and I worked on for a project for a class that I had. Documentation is in the code itself.
Update:
- By deciacco: I uploaded a zip file with the c file and a compiled exe so you can give it a try! You should be able to run the exe in Windows without a problem.
/*
Copyright (C) 2007 Bojan M.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
/**********************************************************************************/
/** Bojan M. *****************************************************************/
/** blackjack.c *****************************************************************/
/** This will play a game of blackjack with the house, and 1 - 3 players for a **/
/** max of 10 hands. Since this game will not employ a wager, the scoring *******/
/** will be as follows: When the player or house get blackjack --> 2pts. ********/
/** If the player or house bust --> 0pts. If the player or house win --> 1pt. ***/
/** Pressing zero will exit the game. *******************************************/
/**********************************************************************************/
#define _CRT_SECURE_NO_DEPRECATE = 1 //Avoid Visual Studio warning
#include
#include
#include
#include
//Required for system()
#include //Required for rand() and srand()
//Value defenitions
#define TRUE 1
#define FALSE 0
#define BUFFSIZE 10
#define NOCARDS 52 //Will need to gen deck later
#define MAXPLAYERS 3
#define MAXHANDS 10
#define RANDSHUF 100
#define PLAYERSIZE 12
#define NEWCARDPOS 11
#define SCORE 0
#define SUM 1
//Function prototypes
void init_cards(int cards[]);
int get_card(int cards[], int *);
void shuf_cards(int cards[], int *);
void show_deck(int cards[]);
int random_int(int, int);
void show_p_hand(int player[][PLAYERSIZE], int);
void show_h_hand(int house[]);
void calc_p_sum(int player[][PLAYERSIZE], int);
void calc_h_sum(int house[]);
void summary(int house[], int player[][PLAYERSIZE], int);
void score(int house[], int player[][PLAYERSIZE], int);
/****************************** START main *********************************/
void main()
{
int i, j, no_players, no_hands, cur_hand = 0;
int cards[NOCARDS]; //Deck of cards
int player[MAXPLAYERS][PLAYERSIZE]; //Holds player stats during game
int house[PLAYERSIZE]; //Holds house stats during game
int play, ask, playhand; //Flags
int nextplayer; //Flag
int deckpos; //Keeps track of where to store next card
char yesno[BUFFSIZE]; //Input buffer
char hitstay[BUFFSIZE];
play = FALSE;
ask = playhand = TRUE;
house[SCORE] = 0; //Initializing the house total score
init_cards(cards); //Calling two functions to generate cards and shuffle them
shuf_cards(cards, &deckpos);
printf("BBBB LL AAA CCCCCC KK KK n");
printf("BB BB LL AA AA CC CC KK KK n");
printf("BB BB LL AA AA CC CC KK KK n");
printf("BB BB LL AA AA CC KK KK n");
printf("BB BB LL AA AA CC KK KK n");
printf("BB BB LL AA AA CC KK KK n");
printf("BB BB LL AA AA CC KKK n");
printf("BBBB LL AA AA CC KK KK n");
printf("BB BB LL AA AA CC KK KK n");
printf("BB BB LL AAAAAAAAA CC KK KK n");
printf("BB BB LL AAAAAAAAA CC KK KK n");
printf("BB BB LL AA AA CC KK KK n");
printf("BB BB LL AA AA CC CC KK KKn");
printf("BB BB LLLLLLL AA AA CC CC KK KKn");
printf("BBBB LLLLLLL AA AA CCCCCC KK KKnnn");
printf(" JJ AAA CCCCCC KK KKn");
printf(" JJ AA AA CC CC KK KKn");
printf(" JJ AA AA CC CC KK KKn");
printf(" JJ AA AA CC KK KKn");
printf(" JJ AA AA CC KK KKn");
printf(" JJ AA AA CC KK KKn");
printf(" JJ AA AA CC KKKn");
printf(" JJ AA AA CC KK KKn");
printf(" JJ AA AA CC KK KKn");
printf(" JJ AAAAAAAAA CC KK KKn");
printf(" JJ AAAAAAAAA CC KK KKn");
printf(" JJ JJ AA AA CC KK KKn");
printf(" JJ JJ AA AA CC CC KK KKn");
printf(" JJ JJ AA AA CC CC KK KKn");
printf(" JJJJJJJ AA AA CCCCCC KK KKnnnnn");
printf("Let's play some BlackJack!!!nn");
printf("Please enter '1' - '%d' for the number of players, or enter '0' to quit.n", MAXPLAYERS);
//If the user enters '0' ask will equal FALSE and will break out of loop
//Else it will take the input and go on to ask for how many hands
while(ask == TRUE)
{
printf("Enter choice: ");
scanf("%d", &no_players);
if(no_players == 0)
{
ask = FALSE;
}
else if(no_players >= 1 && no_players <= MAXPLAYERS)
{
play = TRUE;
ask = FALSE;
}
}
ask = TRUE;
//system("cls");
//If the user enters '0' ask will equal FALSE and will break out of loop
//Else it will take the input and go on to play the game
if(play == TRUE)
{
play = FALSE;
printf("How many hands do you want to play (max %d hands, '0' to quit.n", MAXHANDS);
while(ask == TRUE)
{
printf("Enter choice: ");
scanf("%d", &no_hands);
if(no_hands == 0)
{
ask = FALSE;
}
else if(no_hands >= 1 && no_hands <= MAXHANDS)
{
play = TRUE;
ask = FALSE;
}
}
//Initializing player score
for(i=0; i
{
player[i][SCORE] = 0;
}
//If the user entered 1 - 3 players play will equal to TRUE so the game starts
if(play == TRUE)
{
//system("cls");
printf("OK, let's play %d hands with %d players!!!nn", no_hands, no_players);
while(playhand == TRUE && cur_hand < no_hands)
{
//Give out current hand to each player
for(i = 0; i < no_players; i++)
{
for(j = 2; j < 4; j++)
{
player[i][j] = get_card(cards, &deckpos);
}
player[i][NEWCARDPOS] = 4; //Next available empty slot in player array
//must always be called after assigning empty slot
calc_p_sum(player, i);
}
//Take out two cards for house
for(j = 2; j < 4; j++)
{
house[j] = get_card(cards, &deckpos);
}
house[NEWCARDPOS] = 4;//Next available empty slot in house array
//must always be called after assigning empty slot
calc_h_sum(house);
//Go through every player for hit or stay
for(i = 0; i < no_players; i++)
{
nextplayer = FALSE;
while(nextplayer == FALSE)
{
printf("Player %dn", i+1);
show_p_hand(player,i); //Will show player X hand
if(player[i][SUM] == 21) //If it's 21, player will get
{ //blackjack and go on to next player
printf("Player %d got BLACKJACK!!!nn", i+1);
nextplayer = TRUE;
}
else
{
if(player[i][SUM] < 21)
{
//Must enter h or s to hit or stay, anything else
//will go to next playesr
printf("Player %d, hit or stay (h or s)?: ", i+1);
scanf("%s", hitstay);
if(hitstay[0] == 'h' || hitstay[0] == 'H')
{
player[i][player[i][NEWCARDPOS]] = get_card(cards, &deckpos);
player[i][NEWCARDPOS] += 1;
calc_p_sum(player, i);
}
else
nextplayer = TRUE;
}
else
{ //If a player get more then 21 it's a Bust and go to
//next player
printf("BUST!!!!nn");
nextplayer = TRUE;
}
}
}
}
//Process house and display it's hand
//if house has 17 or less, draw another card then calc sum
while(house[SUM] < 17)
{
house[house[NEWCARDPOS]] = get_card(cards, &deckpos);
house[NEWCARDPOS] += 1;
calc_h_sum(house);
}
show_h_hand(house); //Shows the house hand
summary(house, player, no_players); //Prints the current hand summary
//Next hand?
//If no, game quits
if (cur_hand < no_hands-1)
{
printf("Next hand? (y,n): ");
scanf("%s", yesno);
printf("n");
if(yesno[0] == 'y' || yesno[0] == 'Y')
{
playhand = TRUE;
shuf_cards(cards, &deckpos);
}
else
{
playhand = FALSE;
}
}
else
playhand = FALSE;
cur_hand += 1;//Increase the hand counter
}
}
}
score(house, player, no_players); //Score at the end of all hands
printf("nnThank you for playing BlackJack.n");
system("PAUSE");
}
/******************************** END main *********************************/
/**************************** START init_cards *****************************/
//Will fill the cards array (can change the number of decks to play
void init_cards(int cards[])
{
int base_cards[13];
int i,j;
//Fill base cards array
for(i = 0; i < 13; i++)
{
if (i <= 9 )
base_cards[i] = i+1;
else
base_cards[i] = 10;
}
//Fill deck with NOCARDS
i = 0;
for(j = 0; j < NOCARDS; j++)
{
cards[j] = base_cards[i];
if(i < 12)
i += 1;
else
i = 0;
}
}
/**************************** END init_cards *******************************/
/**************************** START show_deck ******************************/
//This will show the deck after the cards shuffled, can be used for cheating (kind of)
void show_deck(int cards[])
{
int i;
for(i = 0; i < NOCARDS; i++)
{
printf("%dn",cards[i]);
}
}
/***************************** END show_deck *******************************/
/**************************** START shuf_cards *****************************/
//Shuffles the cards 100 times in the cards array
//Basically it takes one card and swithes it with another in the array
void shuf_cards(int cards[], int *deckpos)
{
int i, tempvalue, randpos, x;
for(i = 0; i <= RANDSHUF; i++)
{
for(x = 0; x < NOCARDS; x++)
{
tempvalue = cards[x];
randpos = random_int(x,NOCARDS-1);
cards[x] = cards[randpos];
cards[randpos] = tempvalue;
}
}
*deckpos = 0; //Reset the card that we are on
//Keeps track of the current array position so all cards that have been
//taken out cannot be taken out anymore
}
/**************************** END shuf_cards *******************************/
/**************************** START random_int *****************************/
//Random function to pick random numbers to pick out of array and swap
int random_int(int min, int max)
{
int rand_int, i;
time_t seconds;
time(&seconds);
srand((unsigned int) seconds); //Seed generator
for (i=0; i
rand_int = rand() % (max - min + 1) + min;
return rand_int;
}
/**************************** END random_int *******************************/
/**************************** START get_card *******************************/
//If user says hit, this function gets the card out of the shuffled array and increases
//the deckpos counter to the next slot in array
int get_card(int cards[], int *deckpos)
{
int cardval;
cardval = cards[*deckpos];
*deckpos += 1;
return cardval;
}
/***************************** END get_hand ********************************/
/*************************** START show_p_hand *****************************/
//Shows player hand
void show_p_hand(int player[][PLAYERSIZE], int p)
{
int i;
for(i = 2; i < player[p][NEWCARDPOS]; i++)
printf("%d ", player[p][i]);
printf(" = %dn", player[p][SUM]);
}
/**************************** END show_p_hand ******************************/
/*************************** START show_h_hand *****************************/
//Shows house hand
void show_h_hand(int house[])
{
int i;
printf("Housen");
for(i = 2; i < house[NEWCARDPOS]; i++)
printf("%d ", house[i]);
printf(" = %dnn", house[SUM]);
}
/**************************** END show_h_hand ******************************/
/*************************** START calc_p_sum ******************************/
//Calculates the player sum, determines if an Ace is 1 or 11
void calc_p_sum(int player[][PLAYERSIZE], int p)
{
int i;
int acepos = 1;
player[p][SUM] = 0; //Reset sum to calc
//Raw sum for player
for(i = 2; i < player[p][NEWCARDPOS]; i++)
{
player[p][SUM] += player[p][i];
}
//Lets check for 1 or 11
for(i = 2; i < player[p][NEWCARDPOS]; i++)
if(player[p][i] == 1)
acepos = i;
if(acepos > 1) //We have either have a 1 or an 11
{
if((player[p][SUM] - 1 + 11) <= 21){
player[p][acepos] = 11;
//New sum for player
player[p][SUM] = 0; //Reset sum to calc
for(i = 2; i < player[p][NEWCARDPOS]; i++)
{
player[p][SUM] += player[p][i];
}
}
}
}
/**************************** END calc_p_sum *******************************/
/************************** START calc_h_sum *******************************/
//Calculates the house sum, determines if an Ace is 1 or 11
void calc_h_sum(int house[])
{
int i;
int acepos = 1;
house[SUM] = 0; //Reset sum to calc
//Raw sum for player
for(i = 2; i < house[NEWCARDPOS]; i++)
{
house[SUM] += house[i];
}
//Lets check for 1 or 11
for(i = 2; i < house[NEWCARDPOS]; i++)
if(house[i] == 1)
acepos = i;
if(acepos > 1) //We have either a 1 or an 11
{
if((house[SUM] - 1 + 11) <= 21){
house[acepos] = 11;
//New sum for player
house[SUM] = 0; //Reset sum to calc
for(i = 2; i < house[NEWCARDPOS]; i++)
{
house[SUM] += house[i];
}
}
}
}
/**************************** END calc_h_sum *******************************/
/***************************** START summary *******************************/
//Goes through all scenarios to determine if it's a Bust, Blackjack, Win, Loss, Push/Tie
void summary(int house[], int player[][PLAYERSIZE], int no_players)
{
int i;
//Go through every player and check score for hand summary
printf("Current Hand summary:n");
for(i = 0; i < no_players; i++)
{
if(house[SUM] > 21 && player[i][SUM] < 21)
{
player[i][SCORE] += 1;
printf("Player %d - Winsn",i+1);
}
else if (player[i][SUM] == 21 && house[SUM] != 21)
{
player[i][SCORE] += 2;
printf("Player %d - BlackJack!n",i+1);
}
else if(player[i][SUM] < house[1] && house[SUM] <= 21)
{
house[SCORE] += 1;
printf("Player %d - Loosesn",i+1);
}
else if(player[i][SUM] > house[SUM] && player[i][SUM] <= 21)
{
player[i][SCORE] += 1;
printf("Player %d - Winsn",i+1);
}
else if(player[i][SUM] > 21)
{
printf("Player %d - Bustn",i+1);
}
else
{
printf("Player %d - Push/Tien",i+1);
}
}
}
/***************************** END summary *********************************/
/***************************** START score *********************************/
//Displays the final overall score for players and house
void score(int house[], int player[][PLAYERSIZE], int no_players)
{
int i;
//Go through every player for hit or stay
printf("nnOverall game scores:n");
for(i = 0; i < no_players; i++)
{
printf("Player %d score: %dn", i+1, player[i][SCORE]);
}
printf("House score: %dn", house[SCORE]);
}
/***************************** END score ************************************/
Download the source file and compiled binary here
If you want to compile it yourself, take a look at this page: MinGW