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

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <time.h>
   4 #include <gtk/gtk.h>
   5
   6 char *colors[] = {"Black", "Blue", "Red", "Yellow"};
   7
   8 typedef enum {BLACK, BLUE, RED, YELLOW} color_t;
   9
  10 typedef struct card {
  11     color_t color;
  12     int number;
  13 } card_t;
  14
  15 #define DECK_MAX_CARDS 104
  16
  17 typedef struct deck {
  18     card_t cards[DECK_MAX_CARDS];
  19     int num_cards;
  20 } deck_t;
  21
  22 #define CARD_GROUP_MAX_CARDS DECK_MAX_CARDS
  23
  24 typedef struct card_group {
  25     card_t cards[CARD_GROUP_MAX_CARDS];
  26     int num_cards;
  27 } card_group_t;
  28
  29 #define BOARD_MAX_CARD_GROUPS (DECK_MAX_CARDS / 3)
  30
  31 typedef struct board {
  32     card_group_t groups[BOARD_MAX_CARD_GROUPS];
  33     int num_groups;
  34 } board_t;
  35
  36 typedef struct player {
  37     card_group_t hand;
  38 } player_t;
  39
  40 #define GAME_MAX_PLAYERS 4
  41 #define GAME_WINDOW_DEFAULT_WIDTH  800
  42 #define GAME_WINDOW_DEFAULT_HEIGHT 600
  43
  44 typedef struct game {
  45     player_t players[GAME_MAX_PLAYERS];
  46     int num_players;
  47     board_t board;
  48     deck_t deck;
  49 } game_t;
  50
  51 static void card_print(card_t card)
  52 {
  53     printf("%6s %2d\n", colors[card.color], card.number + 1);
  54 }
  55
  56 static void card_group_init(card_group_t *card_group)
  57 {
  58     card_group->num_cards = 0;
  59 }
  60
  61 static void board_init(board_t *board)
  62 {
  63     int i;
  64     board->num_groups = 0;
  65
  66     for (i = 0; i <= BOARD_MAX_CARD_GROUPS; ++i)
  67     {
  68         card_group_init(&board->groups[i]);
  69     }
  70 }
  71
  72 static void player_init(player_t *player)
  73 {
  74     card_group_init(&player->hand);
  75 }
  76
  77
  78 static int card_compare(card_t *card_one, card_t *card_two)
  79 {
  80     if (card_one->number < card_two->number)
  81         return -1;
  82     if (card_one->number == card_two->number)
  83         return 0;
  84     /* At this point, we know that this must be true:
  85      * if (card_one->number > card_two->number)
  86      */
  87     return 1;
  88 }
  89
  90 static int card_group_is_run(card_group_t *card_group)
  91 {
  92     int i;
  93     int lowest = 14, highest = 0;
  94     if (card_group->num_cards > 13 || card_group->num_cards < 3)
  95     {
  96         return 0;
  97     }
  98     for (i = 0; i < card_group->num_cards - 1; ++i)
  99     {
 100         if (card_group->cards[i].color != card_group->cards[i + 1].color)
 101         {
 102             return 0;
 103         }
 104         if (card_group->cards[i].number > highest)
 105         {
 106             highest = card_group->cards[i].number;
 107         }
 108         if (card_group->cards[i].number < lowest)
 109         {
 110             lowest = card_group->cards[i].number;
 111         }
 112     }
 113     if (highest - lowest != card_group->num_cards - 1)
 114     {
 115         return 0;
 116     }
 117     return 1;
 118 }
 119
 120 static int card_group_is_set(card_group_t *card_group)
 121 {
 122     int i;
 123     color_t seen_color[card_group->num_cards];
 124
 125     if (card_group->num_cards > 4 || card_group->num_cards < 3)
 126     {
 127         return 0;
 128     }
 129     for (i = 0; i < card_group->num_cards - 1; ++i)
 130     {
 131         if (card_group->cards[i].number != card_group->cards[i + 1].number)
 132         {
 133             return 0;
 134         }
 135     }
 136     seen_color[i] = card_group->cards[i].color;
 137     for (i = 0; i < card_group->num_cards; ++i)
 138     {
 139         seen_color[card_group->cards[i].color]++;
 140         if (seen_color[card_group->cards[i].color] > 1)
 141         {
 142             return 0;
 143         }
 144     }
 145     return 1;
 146 }
 147
 148 static void deck_deal(game_t *game, deck_t *deck)
 149 {
 150     card_t temp;
 151     int rand_card;
 152     int i, j, newline;
 153
 154     printf ("How many players(1-4) should I deal in? ");
 155     game->num_players = getchar();
 156     if (game->num_players == EOF)
 157     {
 158         printf ("\nGoodbye.\n");
 159         exit (1);
 160     }
 161     newline = getchar();
 162     game->num_players -= '0';
 163
 164     for (i = 0; i < game->num_players; ++i)
 165     {
 166         for (j = 0; j < 14; ++j)
 167         {
 168             rand_card = ((deck->num_cards + 1.0) * rand()) / (RAND_MAX + 1.0);
 169             temp = deck->cards[rand_card];
 170             deck->cards[rand_card] = deck->cards[deck->num_cards - 1];
 171             game->players[i].hand.cards[j] = temp;
 172             deck->num_cards -= 1;
 173             game->players[i].hand.num_cards += 1;
 174         }
 175     }
 176     printf ("Game dealt for %d player(s)\n", game->num_players);
 177 }
 178
 179 static void deck_init(deck_t *deck)
 180 {
 181     int h, i, j;
 182     deck->num_cards = 0;
 183     for (h = 0; h <= 1; ++h)
 184     {
 185         for (i = 0; i <= 3; ++i)
 186         {
 187             for (j = 0; j <= 12; ++j)
 188             {
 189                 deck->cards[j + (i * 13) + (h * 52)].color = i;
 190                 deck->cards[j + (i * 13) + (h * 52)].number = j;
 191                 deck->num_cards += 1;
 192                 printf ("There are %d tiles in the deck\n", deck->num_cards);
 193             }
 194         }
 195     }
 196 }
 197
 198 static void deck_shuffle(deck_t *deck)
 199 {
 200     card_t temp;
 201     int rand_card;
 202     int last;
 203     for (last = deck->num_cards; last > 0; --last)
 204     {
 205         rand_card = ((last + 1.0) * rand()) / (RAND_MAX + 1.0);
 206         temp = deck->cards[rand_card];
 207         deck->cards[rand_card] = deck->cards[last - 1];
 208         deck->cards[last - 1] = temp;
 209     }
 210 }
 211
 212 static void deck_print(deck_t *deck)
 213 {
 214     int h, i, j;
 215     for (h = 0; h <= 1; ++h)
 216     {
 217         for (i = 0; i <= 3; ++i)
 218         {
 219             for (j = 0; j <= 12; ++j)
 220             {
 221                 card_print(deck->cards[j + (i * 13) + (h * 52)]);
 222             }
 223         }
 224     }
 225     printf ("There are %d tiles in the deck\n" , deck->num_cards);
 226 }
 227
 228 static void hand_print(game_t *game)
 229 {
 230     int i;
 231     for (i = 0; i < game->players[0].hand.num_cards; ++i)
 232     {
 233         card_print(game->players[0].hand.cards[i]);
 234     }
 235 }
 236
 237 static void game_init(game_t *game)
 238 {
 239     int i;
 240     game->num_players = 0;
 241
 242     for (i = 0; i < GAME_MAX_PLAYERS; ++i)
 243     {
 244         player_init(&game->players[i]);
 245         game->num_players += 1;
 246     }
 247
 248     board_init(&game->board);
 249     deck_init(&game->deck);
 250     deck_shuffle(&game->deck);
 251 }
 252
 253 static gboolean on_expose_event (GtkWidget *widget, GdkEventExpose *event, game_t *game)
 254 {
 255     printf ("I should be drawing something here\n");
 256
 257     return TRUE;
 258 }
 259
 260 static gboolean on_key_press_event (GtkWidget *widget, GdkEventKey *event, game_t *game)
 261 {
 262     printf ("You pressed key %d\n", event->keyval);
 263
 264     return TRUE;
 265 }
 266
 267 static gboolean on_button_press_event (GtkWidget *widget, GdkEventButton *event, game_t *game)
 268 {
 269     printf ("You pressed button %d\n", event->button);
 270
 271     return TRUE;
 272 }
 273
 274 static gboolean on_button_release_event (GtkWidget *widget, GdkEventButton *event, game_t *game)
 275 {
 276     printf ("You released button %d\n", event->button);
 277
 278     return TRUE;
 279 }
 280
 281 int main(int argc, char *argv[])
 282 {
 283     GtkWidget *window;
 284     game_t game;
 285
 286     srand(time(NULL));
 287
 288     game_init(&game);
 289     deck_print(&game.deck);
 290     deck_deal(&game, &game.deck);
 291     hand_print(&game);
 292     deck_print(&game.deck);
 293
 294     gtk_init (&argc, &argv);
 295
 296     /* Create a new window */
 297     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 298     gtk_window_set_default_size (GTK_WINDOW (window),
 299                                  GAME_WINDOW_DEFAULT_WIDTH,
 300                                  GAME_WINDOW_DEFAULT_HEIGHT);
 301
 302     gtk_widget_set_events (window,
 303                            GDK_EXPOSURE_MASK |
 304                            GDK_KEY_PRESS_MASK |
 305                            GDK_BUTTON_PRESS_MASK |
 306                            GDK_BUTTON_RELEASE_MASK);
 307
 308     g_signal_connect (G_OBJECT (window), "delete_event",
 309                       G_CALLBACK (gtk_main_quit), NULL);
 310     g_signal_connect (G_OBJECT (window), "expose_event",
 311                       G_CALLBACK (on_expose_event), &game);
 312     g_signal_connect (G_OBJECT (window), "key_press_event",
 313                       G_CALLBACK (on_key_press_event), &game);
 314     g_signal_connect (G_OBJECT (window), "button_press_event",
 315                       G_CALLBACK (on_button_press_event), &game);
 316     g_signal_connect (G_OBJECT (window), "button_release_event",
 317                       G_CALLBACK (on_button_release_event), &game);
 318
 319     gtk_widget_show_all (window);
 320     gtk_main ();
 321
 322     return 0;
 323
 324 }