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 static int card_group_is_run(card_group_t *card_group)
  75 {
  76     int i;
  77     int lowest = 14, highest = 0;
  78     if (card_group->num_cards > 13 || card_group->num_cards < 3)
  79     {
  80         return 0;
  81     }
  82     for (i = 0; i < card_group->num_cards - 1; ++i)
  83     {
  84         if (card_group->cards[i].color != card_group->cards[i + 1].color)
  85         {
  86             return 0;
  87         }
  88         if (card_group->cards[i].number > highest)
  89         {
  90             highest = card_group->cards[i].number;
  91         }
  92         if (card_group->cards[i].number < lowest)
  93         {
  94             lowest = card_group->cards[i].number;
  95         }
  96     }
  97     if (highest - lowest != card_group->num_cards - 1)
  98     {
  99         return 0;
 100     }
 101     return 1;
 102 }
 103
 104
 105 static int card_group_is_set(card_group_t *card_group)
 106 {
 107     int i;
 108     color_t seen_color[card_group->num_cards];
 109
 110     if (card_group->num_cards > 4 || card_group->num_cards < 3)
 111     {
 112         return 0;
 113     }
 114     for (i = 0; i < card_group->num_cards - 1; ++i)
 115     {
 116         if (card_group->cards[i].number != card_group->cards[i + 1].number)
 117         {
 118             return 0;
 119         }
 120     }
 121     seen_color[i] = card_group->cards[i].color;
 122     for (i = 0; i < card_group->num_cards; ++i)
 123     {
 124         seen_color[card_group->cards[i].color]++;
 125         if (seen_color[card_group->cards[i].color] > 1)
 126         {
 127             return 0;
 128         }
 129     }
 130     return 1;
 131 }
 132
 133 #if 0
 134 static void deck_deal(deck_t *deck, game_t *game)
 135 {
 136     card_t temp;
 137     int rand_card;
 138     int i, j;
 139     for (i = 0; i < PLAYERS; ++i)
 140     {
 141         for (j = 0; j < 13; ++j)
 142         {
 143             rand_card = ((last + 1.0) * rand()) / (RAND_MAX + 1.0);
 144             temp = deck->cards[rand_card];
 145             deck->cards[rand_card] = deck->cards[last];
 146             game->players[i]->hand->cards[j] = temp;
 147         }
 148     }
 149 }
 150 #endif
 151
 152 static void deck_init(deck_t *deck)
 153 {
 154     int h, i, j;
 155     deck->num_cards = 0;
 156     for (h = 0; h <= 1; ++h)
 157     {
 158         for (i = 0; i <= 3; ++i)
 159         {
 160             for (j = 0; j <= 12; ++j)
 161             {
 162                 deck->cards[j + (i * 13) + (h * 52)].color = i;
 163                 deck->cards[j + (i * 13) + (h * 52)].number = j;
 164                 deck->num_cards += 1;
 165                 printf ("There are %d tiles in the deck\n", deck->num_cards);
 166             }
 167         }
 168     }
 169 }
 170
 171 static void deck_shuffle(deck_t *deck)
 172 {
 173     card_t temp;
 174     int rand_card;
 175     int last;
 176     for (last = deck->num_cards; last > 0; --last)
 177     {
 178         rand_card = ((last + 1.0) * rand()) / (RAND_MAX + 1.0);
 179         temp = deck->cards[rand_card];
 180         deck->cards[rand_card] = deck->cards[last];
 181         deck->cards[last] = temp;
 182     }
 183 }
 184
 185 static void deck_print(deck_t *deck)
 186 {
 187     int h, i, j;
 188     for (h = 0; h <= 1; ++h)
 189     {
 190         for (i = 0; i <= 3; ++i)
 191         {
 192             for (j = 0; j <= 12; ++j)
 193             {
 194                 card_print(deck->cards[j + (i * 13) + (h * 52)]);
 195             }
 196         }
 197     }
 198     printf ("There are %d tiles in the deck\n" , deck->num_cards);
 199 }
 200
 201 static void game_init(game_t *game)
 202 {
 203     int i;
 204     game->num_players = 0;
 205
 206     for (i = 0; i < GAME_MAX_PLAYERS; ++i)
 207     {
 208         player_init(&game->players[i]);
 209         game->num_players += 1;
 210     }
 211
 212     board_init(&game->board);
 213     deck_init(&game->deck);
 214     deck_shuffle(&game->deck);
 215 }
 216
 217 int main(void)
 218 {
 219     game_t game;
 220
 221     srand(time(NULL));
 222
 223     game_init(&game);
 224     deck_print(&game.deck);
 225
 226     return 0;
 227
 228 }