Thread: Blackjack

Hi there.

I am trying to write a blackjack game and I am running into a few teething problems. My main() function currently outputs what values are stored for certain variables, just to see if I'm doing things properly. Here is the code:

Code:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAX 10

typedef struct {
  int card;
  int suit;
  int value;
} card_t;

void generate_card(card_t *crd, int *num, int *score);

int main(void) {

  /* current scores for dealer and player */
  int p_score = 0;
  int d_score = 0;

  /* number of cards in their hand */
  int p_numofcards = 0;
  int d_numofcards = 0;

  /* initialise hands */
  card_t p_hand[MAX];
  card_t d_hand[MAX];

  srand((unsigned int)time(NULL));

  int i;
  for(i=0;i<2;i++) {          /*loop twice because at the start of blackjack, each player is given two cards*/
    generate_card(&p_hand[i], &p_numofcards, &p_score);
    generate_card(&d_hand[i], &d_numofcards, &d_score);
  }

  /* test */
  printf("p_score=&#37;d, p_numofcards=%d\n", p_score, p_numofcards);
  printf("d_score=%d, d_numofcards=%d\n", d_score, d_numofcards);
int k;
  for(k=0;k<2;k++) {
    printf("p_hand[%d].card=%d,"
           " p_hand[%d].suit=%d, "
           " p_hand[%d].value=%d\n",
            k,p_hand[i].card,
            k,p_hand[i].suit,
            k,p_hand[i].value
           );

  printf("d_hand[%d].card=%d,"
         " d_hand[%d].suit=%d,"
         " d_hand[%d].value=%d\n",
          k,d_hand[i].card,
          k,d_hand[i].suit,
          k,d_hand[i].value
        );
  }

  return 0;
}

void generate_card(card_t *crd, int *num, int *score) {

  /* crd = (card_t *)malloc(MAX*sizeof(card_t)); */

  crd->card = (rand() % 13) + 1;
  crd->suit = (rand() % 4) + 1;
  int c;
  for(c=1;c<11;c++) {   
    if(crd->card == c) {  /*if card is 1-10 (ace- 10) then let the value of the card be whatever it is*/
      crd->value = c;       
      (*score)+=c;              /*adds to the score (eg. 10 of hearts would add a 10) */
      (*num)++;                 /*increments the number of cards in the players' hand*/
    }
  }
  switch(crd->card) {
    case 11: case 12: case 13:            /* if card is jack, queen or king...*/
      crd->value = 10;
      (*score)+=10; 
      (*num)++;   
      break;
  }

  /*free(crd);*/
}

Let me explain a few things. The card_t type represents with the following attributes: card( 1-13 for ace-king), suit(1-4 for hearts, clubs etc), value( ace=1, jack=10, queen=10 and so on). The generate_card function is supposed to generate a random card to simulate the dealer dealing unkown cards to the participants of the game. The program compiles but outputs rather absurd data:

Code:

$ gcc -o bjack bjack.c
$ ./bjack
p_score=8, p_numofcards=2
d_score=8, d_numofcards=2
p_hand[0].card=0, p_hand[0].suit=0,  p_hand[0].value=0
d_hand[0].card=0, d_hand[0].suit=134513052, d_hand[0].value=24641422
p_hand[1].card=0, p_hand[1].suit=0,  p_hand[1].value=0
d_hand[1].card=0, d_hand[1].suit=134513052, d_hand[1].value=24641422

Another run to show it is producing random cards correctly:

Code:

$ ./bjack
p_score=11, p_numofcards=2
d_score=6, d_numofcards=2
p_hand[0].card=0, p_hand[0].suit=0,  p_hand[0].value=0
d_hand[0].card=0, d_hand[0].suit=134513052, d_hand[0].value=24641422
p_hand[1].card=0, p_hand[1].suit=0,  p_hand[1].value=0
d_hand[1].card=0, d_hand[1].suit=134513052, d_hand[1].value=24641422

Any help would be much appreciated, thanks.

> k,p_hand[i].card,
Maybe
k,p_hand[k].card,

Also, you need to introduce the idea of a "deck" of cards, which is initially "shuffled" into random order, then "dealt" one card at a time to each player.
Your technique could easily have both players having the same cards.

Why not just start with every card, swap random cards a few times until all the cards are shuffled, and then take the top card off of the stack? Then you could set that card to NULL and take the next one, etc. This method wouldn't use too much CPU time, except for during initialization.

An array of 52 flags is one method (having "char cards[52]"), but it would require checking the array for unused cards and if used, the randomization is rerun. Using a card number from 1 to 52 in an array of 52 with each randomized is another method. Used cards would be zeros in the deck, unused cards (cards still in the deck) would be 1's in the flag method and the card number using the card number method. For determining the card number, come up with a pattern. I use A to K for 1 to 13 then clubs, diamonds, heats, then spades, for the groups of 13 (note that they are in numerical then alphabetical order). These are just some tips though. There's other ways available.

If you don't want it so 'resource intensive' then use a bitset perhaps? (Or a few bitsets...)

You'd need ~7 bytes to store the flags... (52 / 8, 8 bits to a byte)

It sounds like none of these case statements are executing:

Code:

  switch(crd.suit) {
  case 1:
    strcat(str, "spades");
    break;
  case 2:
    strcat(str, "clubs");
    break;
  case 3:
    strcat(str, "hearts");
    break;
  case 4:
    strcat(str, "diamonds");
  }

Which would mean that crd.suit is invalid. I don't know why, because the rest of your code looks okay. It might give you a starting point.

Rather than using the numeric literal "52" in your program, you should probably be using NUMOFCARDS, and NUMCARDS/2 instead of 26. Just a thought.

Code:

  int h=0;
  int j;
  while(h < 26) {   /*loop 26 times swapping a card from the first 26 with a random one from the last 26*/
    j = randy();
    swapcards(&deck[h],&deck[j]);
    h++;
  }

That works, I suppose, but it puts a slight bias on the results. You could get away with something as simple as

Code:

int x;
for(x = 0; x < NUMCARDS * 10; x ++) {
    swapcards(&deck[rand() &#37; NUMCARDS], &deck[rand() % NUMCARDS]);
}

since swapcards() works perfectly well when passed the same card for both arguments. NUMCARDS*10 swaps might be overkill, but it would give you a very well shuffled deck.

I'll elaborate on "none of the case statements are executing".

Code:

  switch(crd.suit) {
  case 1:
    strcat(str, "spades");
    break;
  case 2:
    strcat(str, "clubs");
    break;
  case 3:
    strcat(str, "hearts");
    break;
  case 4:
    strcat(str, "diamonds");
  }
}

If crd.suit is not 1, 2, 3, or 4, then nothing will get appended to str. You can see this if you do something like this:

Code:

  switch(crd.suit) {
  case 1:
    strcat(str, "spades");
    break;
  case 2:
    strcat(str, "clubs");
    break;
  case 3:
    strcat(str, "hearts");
    break;
  case 4:
    strcat(str, "diamonds");
    break;
  default:
    strcat(str, "*error*");
  }
}

You'd probably get

Code:

The 10th card on the deck is: 4 of *error*

when you ran this modified code.

So, for the 10th card, the suit is not 1, 2, 3, or 4. If you look closely, you'll see that there are already four cards, on of each suit, that have the value 4. So, the 4 in the 10th card is messed up as well. The whole card is probably invalid.

Careful examination shows that there are only three Aces, and so the tenth card should be the Ace of Spades. This is the very first card since spades are represented as 1 in your program.

But wait . . . there are only three Jacks as well. So it's not just the first card that's not being initialized properly.

So there's probably something wrong with this code:

Code:

  int i,k,index;
  for(i=0;i<4;i++) {
    for(k=0;k<13;k++) {
      index = (i*13) + k;
      deck[index].card = k+1;
      deck[index].suit = i+1;
      deck[index].value = value(k+1);
    }
  }

And, you guessed it, I think it's the red line. Multiplying i by 13 doesn't make sense, because i represents the suit and goes from 0 to 3. If you multiplied by 4 instead, it might work.

Code:

index = (i*4) + k;

Anyway, I hope this helps in your debugging.