git.cworth.org Git - ttt/blob - kub/kub.c

   1 #include <stdio.h>\r
   2 #include <stdlib.h>\r
   3 #include <time.h>\r
   4
   5 char *colors[] = {"Black", "Blue", "Red", "Yellow"};
   6
   7 typedef enum {BLACK, BLUE, RED, YELLOW} color_t;
   8
   9 typedef struct card {
  10     color_t color;
  11     int number;
  12 } card_t;
  13
  14 #define DECK_MAX_CARDS 104
  15
  16 typedef struct deck {
  17     card_t cards[DECK_MAX_CARDS];
  18     int num_cards;
  19 } deck_t;
  20
  21 #define CARD_GROUP_MAX_CARDS DECK_MAX_CARDS
  22
  23 typedef struct card_group {
  24     card_t cards[CARD_GROUP_MAX_CARDS];
  25     int num_cards;
  26 } card_group_t;
  27
  28 #define BOARD_MAX_CARD_GROUPS (DECK_MAX_CARDS / 3)
  29
  30 typedef struct board {
  31     card_group_t groups[BOARD_MAX_CARD_GROUPS];
  32     int num_groups;
  33 } board_t;
  34
  35 typedef struct player {
  36     card_group_t hand;
  37 } player_t;
  38
  39 #define GAME_MAX_PLAYERS 4
  40
  41 typedef struct game {
  42     player_t players[GAME_MAX_PLAYERS];
  43     int num_players;
  44     board_t board;
  45     deck_t deck;
  46 } game_t;
  47
  48 static void card_print(card_t card)
  49 {
  50     printf("%6s %2d\n", colors[card.color], card.number + 1);
  51 }
  52
  53 static void card_group_init(card_group_t *card_group)
  54 {
  55     card_group->num_cards = 0;
  56 }
  57
  58 static void board_init(board_t *board)
  59 {
  60     int i;
  61     board->num_groups = 0;
  62
  63     for (i = 0; i <= BOARD_MAX_CARD_GROUPS; ++i)
  64     {
  65         card_group_init(&board->groups[i]);
  66     }
  67 }
  68
  69 static void player_init(player_t *player)
  70 {
  71     card_group_init(&player->hand);
  72 }
  73
  74 #if 0
  75 static int card_group_is_run(card_group_t *card_group)
  76 {
  77     int i;
  78     int lowest = 14, highest = 0;
  79     if (card_group->num_cards > 13 || card_group->num_cards < 3)
  80     {
  81         return 0;
  82     }
  83     for (i = 0; i < card_group->num_cards - 1; ++i)
  84     {
  85         if (card_group->cards[i].color != card_group->cards[i + 1].color)
  86         {
  87             return 0;
  88         }
  89         if (card_group->cards[i].number > highest)
  90         {
  91             highest = card_group->cards[i].number;
  92         }
  93         if (card_group->cards[i].number < lowest)
  94         {
  95             lowest = card_group->cards[i].number;
  96         }
  97     }
  98     if (highest - lowest != card_group->num_cards - 1)
  99     {
 100         return 0;
 101     }
 102     return 1;
 103 }
 104 #endif
 105
 106 #if 0
 107 static int card_group_is_set(card_group_t *card_group)
 108 {
 109     int i;
 110     color_t seen_color[card_group->num_cards];
 111
 112     if (card_group->num_cards > 4 || card_group->num_cards < 3)
 113     {
 114         return 0;
 115     }
 116     for (i = 0; i < card_group->num_cards - 1; ++i)
 117     {
 118         if (card_group->cards[i].number != card_group->cards[i + 1].number)
 119         {
 120             return 0;
 121         }
 122     }
 123     seen_color[i] = card_group->cards[i].color;
 124     for (i = 0; i < card_group->num_cards; ++i)
 125     {
 126         seen_color[card_group->cards[i].color]++;
 127         if (seen_color[card_group->cards[i].color] > 1)
 128         {
 129             return 0;
 130         }
 131     }
 132     return 1;
 133 }
 134 #endif
 135
 136 static void deck_deal(game_t *game, deck_t *deck)
 137 {
 138     card_t temp;
 139     int rand_card;
 140     int i, j, last = deck->num_cards, newline;
 141
 142     printf ("How many players(1-4) should I deal in? ");
 143     game->num_players = getchar();
 144     if (game->num_players == EOF)
 145     {
 146         printf ("\nGoodbye.\n");
 147         exit (1);
 148     }
 149     newline = getchar();
 150     game->num_players -= '0';
 151
 152     for (i = 0; i < game->num_players; ++i)
 153     {
 154         for (j = 0; j < 14; ++j)
 155         {
 156             rand_card = ((last + 1.0) * rand()) / (RAND_MAX + 1.0);
 157             temp = deck->cards[rand_card];
 158             deck->cards[rand_card] = deck->cards[last];
 159             game->players[i].hand.cards[j] = temp;
 160             deck->num_cards -= 1;
 161             game->players[i].hand.num_cards += 1;
 162         }
 163     }
 164     printf ("Game dealt for %d player(s)\n", game->num_players);
 165 }
 166
 167 static void deck_init(deck_t *deck)
 168 {
 169     int h, i, j;
 170     deck->num_cards = 0;
 171     for (h = 0; h <= 1; ++h)
 172     {
 173         for (i = 0; i <= 3; ++i)
 174         {
 175             for (j = 0; j <= 12; ++j)
 176             {
 177                 deck->cards[j + (i * 13) + (h * 52)].color = i;
 178                 deck->cards[j + (i * 13) + (h * 52)].number = j;
 179                 deck->num_cards += 1;
 180                 printf ("There are %d tiles in the deck\n", deck->num_cards);
 181             }
 182         }
 183     }
 184 }
 185
 186 static void deck_shuffle(deck_t *deck)
 187 {
 188     card_t temp;
 189     int rand_card;
 190     int last;
 191     for (last = deck->num_cards; last > 0; --last)
 192     {
 193         rand_card = ((last + 1.0) * rand()) / (RAND_MAX + 1.0);
 194         temp = deck->cards[rand_card];
 195         deck->cards[rand_card] = deck->cards[last];
 196         deck->cards[last] = temp;
 197     }
 198 }
 199
 200 static void deck_print(deck_t *deck)
 201 {
 202     int h, i, j;
 203     for (h = 0; h <= 1; ++h)
 204     {
 205         for (i = 0; i <= 3; ++i)
 206         {
 207             for (j = 0; j <= 12; ++j)
 208             {
 209                 card_print(deck->cards[j + (i * 13) + (h * 52)]);
 210             }
 211         }
 212     }
 213     printf ("There are %d tiles in the deck\n" , deck->num_cards);
 214 }
 215
 216 static void hand_print(game_t *game)
 217 {
 218     int i;
 219     for (i = 0; i < game->players[0].hand.num_cards; ++i)
 220     {
 221         card_print(game->players[0].hand.cards[i]);
 222     }
 223 }
 224
 225 static void game_init(game_t *game)
 226 {
 227     int i;
 228     game->num_players = 0;
 229
 230     for (i = 0; i < GAME_MAX_PLAYERS; ++i)
 231     {
 232         player_init(&game->players[i]);
 233         game->num_players += 1;
 234     }
 235
 236     board_init(&game->board);
 237     deck_init(&game->deck);
 238     deck_shuffle(&game->deck);
 239 }
 240
 241 int main(void)
 242 {
 243     game_t game;
 244
 245     srand(time(NULL));
 246
 247     game_init(&game);
 248     deck_print(&game.deck);
 249     deck_deal(&game, &game.deck);
 250     hand_print(&game);
 251     deck_print(&game.deck);
 252     return 0;
 253
 254 }