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 14
  22
  23 typedef struct card_group {
  24     card_t cards[HAND_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 void card_print(card_t card)
  49 {
  50     printf("%6s %2d\n", colors[card.color], card.number + 1);
  51 }
  52
  53 void card_group_init(card_group_t *card_group)
  54 {
  55     card_group->num_cards = 0;
  56 }
  57
  58 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 void player_init(player_t *player)
  70 {
  71     card_group_init(&player->hand);
  72 }
  73
  74 void game_init(game_t *game)
  75 {
  76     int i;
  77     game->num_players = 0
  78
  79         for (i = 0; i < GAME_MAX_PLAYERS; ++i)
  80         {
  81             player_init(&game->players[i]);
  82             game->num_players += 1;
  83         }
  84
  85     board_init(&game->board);
  86     deck_init(&game->deck);
  87     deck_shuffle(&game->deck);
  88 }
  89
  90 int card_group_is_set(card_group_t *card_group)
  91 {
  92     int i, j;
  93     color_t seen_color[card_group->num_cards]
  94
  95         if (card_group->num_cards > 4 || card_group->num_cards < 3)
  96         {
  97             return 0;
  98         }
  99     for (i = 0; i < card_group->num_cards - 1; ++i)
 100     {
 101         if (card_group->cards[i].number != card_group->cards[i + 1].number)
 102         {
 103             return 0;
 104         }
 105     }
 106     seen_color[i] = card_group->cards[i].color;
 107     for (i = 0; i < card_group->num_cards; ++i)
 108     {
 109         color_t color;
 110
 111         seen_color[card_group->cards[i].color]++;
 112     }
 113     return 1;
 114 }
 115
 116 void deck_deal(deck_t *deck)
 117 {
 118     card_t temp;
 119     int rand_card;
 120     int i;
 121     for (i = 0; i < Players )
 122     {
 123         rand_card = ((last + 1.0) * rand()) / (RAND_MAX + 1.0);
 124         temp = deck->cards[rand_card];
 125         deck->cards[rand_card] = deck->cards[last];
 126         deck->cards[last] = temp;
 127     }
 128 }
 129
 130
 131 void deck_init(deck_t *deck)
 132 {
 133     int h, i, j;
 134     deck->num_cards = 0;
 135     for (h = 0; h <= 1; ++h)
 136     {
 137         for (i = 0; i <= 3; ++i)
 138         {
 139             for (j = 0; j <= 12; ++j)
 140             {
 141                 deck->cards[j + (i * 13) + (h * 52)].color = i;
 142                 deck->cards[j + (i * 13) + (h * 52)].number = j;
 143                 deck->num_cards += 1;
 144             }
 145         }
 146     }
 147 }
 148
 149 void deck_shuffle(deck_t *deck)
 150 {
 151     card_t temp;
 152     int rand_card;
 153     int last;
 154     for (last = deck->num_cards; last > 0; --last)
 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         deck->cards[last] = temp;
 160     }
 161 }
 162
 163 void deck_print(deck_t *deck)
 164 {
 165     int h, i, j;
 166     for (h = 0; h <= 1; ++h)
 167     {
 168         for (i = 0; i <= 3; ++i)
 169         {
 170             for (j = 0; j <= 12; ++j)
 171             {
 172                 card_print(deck->cards[j + (i * 13) + (h * 52)]);
 173             }
 174         }
 175     }
 176 }
 177
 178 int main()
 179 {
 180 #define MAX_PLAYERS 4
 181 #define HANDSIZE 14
 182 #define PLAYERS 4
 183
 184     deck_t deck;
 185
 186     srand(time(NULL));
 187
 188     game_init(&game);
 189     deck_print(&deck);
 190
 191     return 0;
 192