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     if (card_one.number > card_two.number)
  85         return 1;
  86 }
  87
  88 static int card_group_is_run(card_group_t *card_group)
  89 {
  90     if (card_group->num_cards > 13 || card_group->num_cards < 3)
  91     {
  92         return 0;
  93     }
  94     for (i = 0; i < card_group->num_cards - 1; ++i)
  95         if(card_group->cards[i].color != card_group->cards[i + 1].color)
  96         {
  97             return 0;
  98         }
  99     for (i = 0; i < card_group->num_cards - 1; ++i)
 100         if(card_group->cards[i].number != card_group->cards[i + 1].number -1)
 101         {
 102             return 0;
 103         }
 104     return 1;
 105 }
 106
 107 static int card_group_is_run(card_group_t *card_group)
 108 {
 109     int i;
 110     int lowest = 14, highest = 0;
 111     if (card_group->num_cards > 13 || card_group->num_cards < 3)
 112     {
 113         return 0;
 114     }
 115     for (i = 0; i < card_group->num_cards - 1; ++i)
 116     {
 117         if (card_group->cards[i].color != card_group->cards[i + 1].color)
 118         {
 119             return 0;
 120         }
 121         if (card_group->cards[i].number > highest)
 122         {
 123             highest = card_group->cards[i].number;
 124         }
 125         if (card_group->cards[i].number < lowest)
 126         {
 127             lowest = card_group->cards[i].number;
 128         }
 129     }
 130     if (highest - lowest != card_group->num_cards - 1)
 131     {
 132         return 0;
 133     }
 134     return 1;
 135 }
 136
 137 static int card_group_is_set(card_group_t *card_group)
 138 {
 139     int i;
 140     color_t seen_color[card_group->num_cards];
 141
 142     if (card_group->num_cards > 4 || card_group->num_cards < 3)
 143     {
 144         return 0;
 145     }
 146     for (i = 0; i < card_group->num_cards - 1; ++i)
 147     {
 148         if (card_group->cards[i].number != card_group->cards[i + 1].number)
 149         {
 150             return 0;
 151         }
 152     }
 153     seen_color[i] = card_group->cards[i].color;
 154     for (i = 0; i < card_group->num_cards; ++i)
 155     {
 156         seen_color[card_group->cards[i].color]++;
 157         if (seen_color[card_group->cards[i].color] > 1)
 158         {
 159             return 0;
 160         }
 161     }
 162     return 1;
 163 }
 164
 165 static void deck_deal(game_t *game, deck_t *deck)
 166 {
 167     card_t temp;
 168     int rand_card;
 169     int i, j, newline;
 170
 171     printf ("How many players(1-4) should I deal in? ");
 172     game->num_players = getchar();
 173     if (game->num_players == EOF)
 174     {
 175         printf ("\nGoodbye.\n");
 176         exit (1);
 177     }
 178     newline = getchar();
 179     game->num_players -= '0';
 180
 181     for (i = 0; i < game->num_players; ++i)
 182     {
 183         for (j = 0; j < 14; ++j)
 184         {
 185             rand_card = ((deck->num_cards + 1.0) * rand()) / (RAND_MAX + 1.0);
 186             temp = deck->cards[rand_card];
 187             deck->cards[rand_card] = deck->cards[deck->num_cards - 1];
 188             game->players[i].hand.cards[j] = temp;
 189             deck->num_cards -= 1;
 190             game->players[i].hand.num_cards += 1;
 191         }
 192     }
 193     printf ("Game dealt for %d player(s)\n", game->num_players);
 194 }
 195
 196 static void deck_init(deck_t *deck)
 197 {
 198     int h, i, j;
 199     deck->num_cards = 0;
 200     for (h = 0; h <= 1; ++h)
 201     {
 202         for (i = 0; i <= 3; ++i)
 203         {
 204             for (j = 0; j <= 12; ++j)
 205             {
 206                 deck->cards[j + (i * 13) + (h * 52)].color = i;
 207                 deck->cards[j + (i * 13) + (h * 52)].number = j;
 208                 deck->num_cards += 1;
 209                 printf ("There are %d tiles in the deck\n", deck->num_cards);
 210             }
 211         }
 212     }
 213 }
 214
 215 static void deck_shuffle(deck_t *deck)
 216 {
 217     card_t temp;
 218     int rand_card;
 219     int last;
 220     for (last = deck->num_cards; last > 0; --last)
 221     {
 222         rand_card = ((last + 1.0) * rand()) / (RAND_MAX + 1.0);
 223         temp = deck->cards[rand_card];
 224         deck->cards[rand_card] = deck->cards[last - 1];
 225         deck->cards[last - 1] = temp;
 226     }
 227 }
 228
 229 static void deck_print(deck_t *deck)
 230 {
 231     int h, i, j;
 232     for (h = 0; h <= 1; ++h)
 233     {
 234         for (i = 0; i <= 3; ++i)
 235         {
 236             for (j = 0; j <= 12; ++j)
 237             {
 238                 card_print(deck->cards[j + (i * 13) + (h * 52)]);
 239             }
 240         }
 241     }
 242     printf ("There are %d tiles in the deck\n" , deck->num_cards);
 243 }
 244
 245 static void hand_print(game_t *game)
 246 {
 247     int i;
 248     for (i = 0; i < game->players[0].hand.num_cards; ++i)
 249     {
 250         card_print(game->players[0].hand.cards[i]);
 251     }
 252 }
 253
 254 static void game_init(game_t *game)
 255 {
 256     int i;
 257     game->num_players = 0;
 258
 259     for (i = 0; i < GAME_MAX_PLAYERS; ++i)
 260     {
 261         player_init(&game->players[i]);
 262         game->num_players += 1;
 263     }
 264
 265     board_init(&game->board);
 266     deck_init(&game->deck);
 267     deck_shuffle(&game->deck);
 268 }
 269
 270 static gboolean on_expose_event (GtkWidget *widget, GdkEventExpose *event, game_t *game)
 271 {
 272     printf ("I should be drawing something here\n");
 273
 274     return TRUE;
 275 }
 276
 277 static gboolean on_key_press_event (GtkWidget *widget, GdkEventKey *event, game_t *game)
 278 {
 279     printf ("You pressed key %d\n", event->keyval);
 280
 281     return TRUE;
 282 }
 283
 284 static gboolean on_button_press_event (GtkWidget *widget, GdkEventButton *event, game_t *game)
 285 {
 286     printf ("You pressed button %d\n", event->button);
 287
 288     return TRUE;
 289 }
 290
 291 static gboolean on_button_release_event (GtkWidget *widget, GdkEventButton *event, game_t *game)
 292 {
 293     printf ("You released button %d\n", event->button);
 294
 295     return TRUE;
 296 }
 297
 298 int main(int argc, char *argv[])
 299 {
 300     GtkWidget *window;
 301     game_t game;
 302
 303     srand(time(NULL));
 304
 305     game_init(&game);
 306     deck_print(&game.deck);
 307     deck_deal(&game, &game.deck);
 308     hand_print(&game);
 309     deck_print(&game.deck);
 310
 311     gtk_init (&argc, &argv);
 312
 313     /* Create a new window */
 314     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 315     gtk_window_set_default_size (GTK_WINDOW (window),
 316                                  GAME_WINDOW_DEFAULT_WIDTH,
 317                                  GAME_WINDOW_DEFAULT_HEIGHT);
 318
 319     gtk_widget_set_events (window,
 320                            GDK_EXPOSURE_MASK |
 321                            GDK_KEY_PRESS_MASK |
 322                            GDK_BUTTON_PRESS_MASK |
 323                            GDK_BUTTON_RELEASE_MASK);
 324
 325     g_signal_connect (G_OBJECT (window), "delete_event",
 326                       G_CALLBACK (gtk_main_quit), NULL);
 327     g_signal_connect (G_OBJECT (window), "expose_event",
 328                       G_CALLBACK (on_expose_event), &game);
 329     g_signal_connect (G_OBJECT (window), "key_press_event",
 330                       G_CALLBACK (on_key_press_event), &game);
 331     g_signal_connect (G_OBJECT (window), "button_press_event",
 332                       G_CALLBACK (on_button_press_event), &game);
 333     g_signal_connect (G_OBJECT (window), "button_release_event",
 334                       G_CALLBACK (on_button_release_event), &game);
 335
 336     gtk_widget_show_all (window);
 337     gtk_main ();
 338
 339     return 0;
 340
 341 }