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 #include <librsvg/rsvg.h>
   6 #include <librsvg/rsvg-cairo.h>
   7
   8 /*
   9  *   TILE_NUMBER_X_OFFSET = 3
  10  * //
  11  * || TILE_NUMBER_WIDTH = 34
  12  * ||/   /
  13  * ||   |  TILE_WIDTH = 40
  14  * ||   | /
  15  * |     |
  16  * +-----+ - TILE_NUMBER_Y_OFFSET = 3   -
  17  * |+---+| -                            |
  18  * ||   ||                              |
  19  * ||   ||   TILE_NUMBER_HEIGHT = 24    |
  20  * |+---+| -                            |
  21  * |  _  | _                            |-TILE_HEIGHT = 50
  22  * | / \ |                              |
  23  * ||   ||   TILE_SUN_HEIGHT = 20       |
  24  * | \_/ | _                            |
  25  * |     |   TILE_SUN_Y_OFFSET = 3      |
  26  * +-----+ -                            -
  27  * ||   | TILE_SUN_WIDTH = 20
  28  * ||
  29  * || TILE_SUN_X_OFFSET = 10
  30  */
  31 #define TILE_WIDTH              40
  32 #define TILE_HEIGHT             50
  33
  34 #define TILE_NUMBER_X_OFFSET    3
  35 #define TILE_NUMBER_Y_OFFSET    3
  36 #define TILE_NUMBER_WIDTH       34
  37 #define TILE_NUMBER_HEIGHT      24
  38
  39 #define TILE_SUN_X_OFFSET       10
  40 #define TILE_SUN_Y_OFFSET       3
  41 #define TILE_SUN_WIDTH          20
  42 #define TILE_SUN_HEIGHT         20
  43
  44 #define FATAL_ERROR(msg)                                                \
  45     do { fprintf (stderr, "Error: %s\n", msg); exit (1); } while (0)
  46
  47 char *colors[] = {"Black", "Blue", "Red", "Yellow"};
  48
  49 typedef enum {BLACK, BLUE, RED, YELLOW} color_t;
  50
  51 typedef struct tile {
  52     color_t color;
  53     int number;
  54     int x;
  55     int y;
  56 } tile_t;
  57
  58 #define DECK_MAX_TILES 104
  59
  60 typedef struct deck {
  61     tile_t tiles[DECK_MAX_TILES];
  62     int num_tiles;
  63 } deck_t;
  64
  65 #define TILE_GROUP_MAX_TILES DECK_MAX_TILES
  66
  67 typedef struct tile_group {
  68     tile_t tiles[TILE_GROUP_MAX_TILES];
  69     int num_tiles;
  70 } tile_group_t;
  71
  72 #define BOARD_MAX_TILE_GROUPS (DECK_MAX_TILES / 3)
  73
  74 typedef struct board {
  75     tile_group_t groups[BOARD_MAX_TILE_GROUPS];
  76     int num_groups;
  77 } board_t;
  78
  79 typedef struct player {
  80     tile_group_t hand;
  81 } player_t;
  82
  83 typedef struct selection_box {
  84     int x1, x2, y1, y2, visible;
  85 } selection_box_t;
  86
  87 #define GAME_MAX_PLAYERS 4
  88 #define GAME_WINDOW_DEFAULT_WIDTH  800
  89 #define GAME_WINDOW_DEFAULT_HEIGHT 600
  90
  91 typedef struct game {
  92     player_t players[GAME_MAX_PLAYERS];
  93     int num_players;
  94     board_t board;
  95     deck_t deck;
  96     selection_box_t selection_box;
  97     RsvgHandle *blanktile;
  98
  99     int current_tile;
 100     int diff_x, diff_y;
 101     int click_x, click_y;
 102     int release_x, release_y;    /*Currently unused*/
 103 } game_t;
 104
 105 static void selection_box_init(selection_box_t *box)
 106 {
 107     box->x1 = 0;
 108     box->x2 = 0;
 109     box->y1 = 0;
 110     box->y2 = 0;
 111     rect->visible = 0;
 112 }
 113
 114 static void selection_box_draw(selection_box_t *box, cairo_t *cr)
 115 {
 116     int box_x = MIN(box->x1, box->x2);
 117     int box_y = MIN(box->y1, box->y2);
 118     int box_width = abs(box->x2 - box->x1);
 119     int box_height = abs(box->y2 - box->y1);
 120     cairo_rectangle (cr, box_x, box_y, box_width, box_height);
 121     cairo_set_source_rgba(cr, 0.0, 0.1, 0.2, 0.5);
 122     cairo_fill (cr);
 123 }
 124
 125 static void tile_init (tile_t *tile, color_t color, int number)
 126 {
 127     tile->color = color;
 128     tile->number = number;
 129     tile->x = 0;
 130     tile->y = 0;
 131 }
 132
 133 static void tile_set_x_y (tile_t *tile, int x, int y)
 134 {
 135     tile->x = x;
 136     tile->y = y;
 137 }
 138
 139 static void tile_print(tile_t tile)
 140 {
 141     printf("%6s %2d\n", colors[tile.color], tile.number + 1);
 142 }
 143
 144 static void tile_draw(game_t *game, tile_t *tile, cairo_t *cr, GdkRegion *region)
 145 {
 146     char number_string[3];
 147     int len;
 148     GdkRectangle rectangle;
 149
 150     rectangle.x = tile->x - 1;
 151     rectangle.y = tile->y - 1;
 152     rectangle.width = TILE_WIDTH + 2;
 153     rectangle.height = TILE_HEIGHT + 2;
 154     if (gdk_region_rect_in (region, &rectangle) == GDK_OVERLAP_RECTANGLE_OUT)
 155         return;
 156
 157     len = snprintf (number_string, 3, "%d", tile->number + 1);
 158     if (len < 0 || len >= 3)
 159         FATAL_ERROR ("snprintf failed");
 160
 161     cairo_save(cr);
 162     cairo_translate(cr, tile->x, tile->y);
 163     rsvg_handle_render_cairo (game->blanktile, cr);
 164
 165     if (tile->color == BLACK)
 166         cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
 167     if (tile->color == BLUE)
 168         cairo_set_source_rgb (cr, 0.0, 0.0, 1.0);
 169     if (tile->color == RED)
 170         cairo_set_source_rgb (cr, 1.0, 0.0, 0.0);
 171     if (tile->color == YELLOW)
 172         cairo_set_source_rgb (cr, 1.0, .843, 0.0);
 173     if (tile->number + 1 > 9)
 174         cairo_move_to (cr, 1, 25);
 175     else
 176         cairo_move_to (cr, 10, 25);
 177     cairo_set_font_size(cr, 25);
 178     cairo_show_text (cr, number_string);
 179
 180     cairo_restore(cr);
 181 }
 182
 183 static void tile_group_init(tile_group_t *tile_group)
 184 {
 185     tile_group->num_tiles = 0;
 186 }
 187
 188 static void board_init(board_t *board)
 189 {
 190     int i;
 191     board->num_groups = 0;
 192
 193     for (i = 0; i <= BOARD_MAX_TILE_GROUPS; ++i)
 194     {
 195         tile_group_init(&board->groups[i]);
 196     }
 197 }
 198
 199 static void player_init(player_t *player)
 200 {
 201     tile_group_init(&player->hand);
 202 }
 203
 204
 205 /* If tile_one < tile_two, then return value will be negative
 206    if they are equal, 0 will be returned,
 207    if tile_one > tile_two, then return value will be positive */
 208 static int tile_compare(const void *one, const void *two)
 209 {
 210     const tile_t *tile_one = one;
 211     const tile_t *tile_two = two;
 212     return tile_one->number - tile_two->number;
 213 }
 214
 215 static int tile_group_is_run_one(tile_group_t *tile_group)
 216 {
 217     int i;
 218     qsort (&tile_group->tiles[0], tile_group->num_tiles,
 219            sizeof (tile_t), tile_compare);
 220
 221     if (tile_group->num_tiles > 13 || tile_group->num_tiles < 3)
 222     {
 223         printf("fail run - invalid num tiles; ");
 224         return 0;
 225     }
 226     for (i = 0; i < tile_group->num_tiles - 1; ++i)
 227     {
 228         if(tile_group->tiles[i].color != tile_group->tiles[i + 1].color)
 229         {
 230             printf("fail run - colors don't match; ");
 231             return 0;
 232         }
 233         if( tile_group->tiles[i].number != tile_group->tiles[i + 1].number -1 &&
 234             i+1 != tile_group->num_tiles)
 235         {
 236             printf("fail run - invalid number sequence; ");
 237             return 0;
 238         }
 239     }
 240     return 1;
 241 }
 242
 243
 244 static int tile_group_is_run_two(tile_group_t *tile_group)
 245 {
 246     int i;
 247     int lowest = 14, highest = 0;
 248     color_t run_color;
 249
 250     /* By definition, a run must have at least 3 tiles. Also, it's
 251      * impossible for any group of tiles with more than 13 tiles to be
 252      * a run, (there are only 13 unique numbers so a group with more
 253      * than 13 tiles must have some duplicates).
 254      */
 255     if (tile_group->num_tiles < 3 || tile_group->num_tiles > 13)
 256     {
 257         return 0;
 258     }
 259
 260     /* Loop through all tiles in the group, ensuring that they are all
 261      * the same color and finding the highest and lowest number in the
 262      * group. */
 263     run_color = tile_group->tiles[0].color;
 264
 265     for (i = 0; i < tile_group->num_tiles; i++)
 266     {
 267         if (tile_group->tiles[i].color != run_color)
 268             return 0;
 269         if (tile_group->tiles[i].number > highest)
 270         {
 271             highest = tile_group->tiles[i].number;
 272         }
 273         if (tile_group->tiles[i].number < lowest)
 274         {
 275             lowest = tile_group->tiles[i].number;
 276         }
 277     }
 278
 279     /* For a run, the difference between the highest and lowest tiles
 280      * will always be one less than the number of tiles in the
 281      * group. If not then we know it's not a run.
 282      */
 283     if (highest - lowest != tile_group->num_tiles - 1)
 284     {
 285         return 0;
 286     }
 287
 288     /* XXX: There's a bug here. We're guessing that at this point
 289      * anything we're looking at must be a run. This would be correct
 290      * if there were no duplicate tiles, but since there are
 291      * duplicates this us quite broken. For example consider two
 292      * sequences of entirely red tiles:
 293      *
 294      * This is a run:   1, 2, 3, 4
 295      * But this is not: 1, 3, 4, 4
 296      *
 297      * As currently written, this function will consider both of these
 298      * groups to be a run. One possible fix is to throw away the
 299      * highest - lowest heuristic and instead simply sort the tiles up
 300      * front and ensure the difference between each adjacent pair is
 301      * exactly 1.
 302      */
 303     return 1;
 304 }
 305
 306 static int tile_group_is_set(tile_group_t *tile_group)
 307 {
 308     int i;
 309     color_t seen_color[4];
 310     for (i = 0; i < 4; i++)
 311         seen_color[i] = 0;
 312
 313     if (tile_group->num_tiles > 4 || tile_group->num_tiles < 3)
 314     {
 315         printf("fail set - invalid num tiles; ");
 316         return 0;
 317     }
 318     for (i = 0; i <= tile_group->num_tiles - 1; ++i)
 319     {
 320         if (tile_group->tiles[i].number != tile_group->tiles[i + 1].number &&
 321             i+1 != tile_group->num_tiles)
 322         {
 323             printf("fail set - numbers don't match; ");
 324             return 0;
 325         }
 326         seen_color[tile_group->tiles[i].color] += 1;
 327     }
 328     for (i = 0; i < 4; i++)
 329     {
 330         if (seen_color[i] > 1)
 331         {
 332             printf("fail set - repeat color; ");
 333             return 0;
 334         }
 335     }
 336     return 1;
 337 }
 338
 339 static void deck_deal(game_t *game, deck_t *deck)
 340 {
 341     tile_t temp;
 342     int rand_tile;
 343     int i, j, newline;
 344
 345     printf ("How many players(1-4) should I deal in? ");
 346     game->num_players = getchar();
 347     if (game->num_players == EOF)
 348     {
 349         printf ("\nGoodbye.\n");
 350         exit (1);
 351     }
 352     newline = getchar();
 353     game->num_players -= '0';
 354
 355     for (i = 0; i < game->num_players; ++i)
 356     {
 357         for (j = 0; j < 14; ++j)
 358         {
 359             rand_tile = ((deck->num_tiles + 1.0) * rand()) / (RAND_MAX + 1.0);
 360             temp = deck->tiles[rand_tile];
 361             deck->tiles[rand_tile] = deck->tiles[deck->num_tiles - 1];
 362             game->players[i].hand.tiles[j] = temp;
 363             deck->num_tiles -= 1;
 364             game->players[i].hand.num_tiles += 1;
 365         }
 366     }
 367     printf ("Game dealt for %d player(s)\n", game->num_players);
 368 }
 369
 370 static void deck_init(deck_t *deck)
 371 {
 372     int h, i, j;
 373     deck->num_tiles = 0;
 374     for (h = 0; h <= 1; ++h)
 375     {
 376         for (i = 0; i <= 3; ++i)
 377         {
 378             for (j = 0; j <= 12; ++j)
 379             {
 380                 tile_init (&deck->tiles[deck->num_tiles++], i, j);
 381                 printf ("There are %d tiles in the deck\n", deck->num_tiles);
 382             }
 383         }
 384     }
 385 }
 386
 387 static void deck_shuffle(deck_t *deck)
 388 {
 389     tile_t temp;
 390     int rand_tile;
 391     int last;
 392     for (last = deck->num_tiles; last > 0; --last)
 393     {
 394         rand_tile = ((last + 1.0) * rand()) / (RAND_MAX + 1.0);
 395         temp = deck->tiles[rand_tile];
 396         deck->tiles[rand_tile] = deck->tiles[last - 1];
 397         deck->tiles[last - 1] = temp;
 398     }
 399 }
 400
 401 static void deck_print(deck_t *deck)
 402 {
 403     int h, i, j;
 404     for (h = 0; h < 2; ++h)
 405     {
 406         for (i = 0; i < 4; ++i)
 407         {
 408             for (j = 0; j < 13; ++j)
 409             {
 410                 tile_print(deck->tiles[j + (i * 13) + (h * 52)]);
 411             }
 412         }
 413     }
 414     printf ("There are %d tiles in the deck\n" , deck->num_tiles);
 415 }
 416
 417 static void deck_spread(deck_t *deck)
 418 {
 419     int i, j;
 420     for (i = 0; i < 8; i++)
 421     {
 422         for (j = 0; j < 13; j++)
 423         {
 424             deck->tiles[j + (i * 13)].x = j * 50;
 425             deck->tiles[j + (i * 13)].y = i * 60;
 426         }
 427     }
 428 }
 429
 430 static void deck_draw(game_t *game, cairo_t *cr, GdkRegion *region)
 431 {
 432     int i;
 433     for (i = 0; i < game->deck.num_tiles; i++)
 434     {
 435         tile_draw(game, &game->deck.tiles[i], cr, region);
 436     }
 437 }
 438
 439 static void hand_print(game_t *game, int player)
 440 {
 441     int i;
 442     for (i = 0; i < game->players[player].hand.num_tiles; i++)
 443     {
 444         tile_print(game->players[player].hand.tiles[i]);
 445     }
 446 }
 447
 448 static void hand_draw(game_t *game, int player, cairo_t *cr, GdkRegion *region)
 449 {
 450     int i;
 451     int gwdw = GAME_WINDOW_DEFAULT_WIDTH;
 452     int gwdh = GAME_WINDOW_DEFAULT_HEIGHT;
 453     for (i = 0; i < game->players[player].hand.num_tiles; i++)
 454     {
 455         tile_set_x_y(&game->players[player].hand.tiles[i],
 456                      ((gwdw / game->players[player].hand.num_tiles)) * i,
 457                      (gwdh - TILE_HEIGHT - 6) );
 458     }
 459     for (i = 0; i < game->players[player].hand.num_tiles; i++)
 460     {
 461         tile_draw(game, &game->players[player].hand.tiles[i], cr, region);
 462     }
 463 }
 464
 465 static void game_init(game_t *game)
 466 {
 467     int i;
 468     GError *error = NULL;
 469
 470     game->num_players = 0;
 471
 472     for (i = 0; i < GAME_MAX_PLAYERS; ++i)
 473     {
 474         player_init(&game->players[i]);
 475         game->num_players += 1;
 476     }
 477
 478     selection_box_init(&game->selection_box);
 479     board_init(&game->board);
 480     deck_init(&game->deck);
 481     deck_shuffle(&game->deck);
 482
 483     game->blanktile = rsvg_handle_new_from_file ("tiles/blanktile.svg", &error);
 484     if (error)
 485         FATAL_ERROR (error->message);
 486
 487     /*This line appears to be useless, has been replaced by line below*/
 488     //game->current_tile = game->deck.num_tiles - 1;
 489     game->current_tile = -1;
 490
 491     game->diff_x = game->diff_y = 0;
 492 }
 493
 494 static gboolean on_expose_event (GtkWidget *widget, GdkEventExpose *event, game_t *game)
 495 {
 496     cairo_t *cr;
 497
 498     cr = gdk_cairo_create (widget->window);
 499
 500     deck_draw(game, cr, event->region);
 501
 502     if (game->selection_box.visible)
 503         selection_box_draw(&game->selection_box, cr);
 504
 505     hand_draw(game, 0, cr, event->region);
 506
 507     cairo_destroy (cr);
 508
 509     return TRUE;
 510 }
 511
 512 static gboolean on_key_press_event (GtkWidget *widget, GdkEventKey *event, game_t *game)
 513 {
 514     printf ("You pressed key %d\n", event->keyval);
 515
 516     return TRUE;
 517 }
 518
 519 static gboolean on_button_press_event (GtkWidget *widget, GdkEventButton *event, game_t *game)
 520 {
 521     int i, tile_x, tile_y;
 522
 523     for (i = 0; i < game->deck.num_tiles; i++)
 524     {
 525         tile_x = game->deck.tiles[i].x;
 526         tile_y = game->deck.tiles[i].y;
 527         if (event->x >= tile_x && event->x <= (tile_x + TILE_WIDTH) &&
 528             event->y >= tile_y && event->y <= (tile_y + TILE_HEIGHT) )
 529         {
 530             game->current_tile = i;
 531             game->diff_x = event->x - tile_x;
 532             game->diff_y = event->y - tile_y;
 533         }
 534     }
 535     if (game->current_tile == -1)
 536     {
 537         game->selection_box.visible = 1;
 538         /*These next two lines are likely to be replaced by...*/
 539         game->click_x = event->x;
 540         game->click_y = event->y;
 541         /*...these two lines*/
 542         game->selection_box.x1 = event->x;
 543         game->selection_box.y1 = event->y;
 544     }
 545     return TRUE;
 546 }
 547
 548 static gboolean on_button_release_event (GtkWidget *widget, GdkEventButton *event, game_t *game)
 549 {
 550     if (game->current_tile == -1)
 551     {
 552         selection_box_t *box;
 553         box = &game->selection_box;
 554
 555         box->visible = 0;
 556         gtk_widget_queue_draw_area (widget, box->x, box->y, box->width, box->height);
 557
 558         tile_group_t group;
 559         group.num_tiles = 0;
 560
 561         int i, tile_x, tile_y;
 562         for (i = 0; i < game->deck.num_tiles; i++)
 563         {
 564             tile_x = game->deck.tiles[i].x;
 565             tile_y = game->deck.tiles[i].y;
 566             if ( (event->x >= tile_x && game->click_x <= tile_x &&
 567                   event->y >= tile_y && game->click_y <= tile_y) ||
 568                  (event->x >= tile_x && game->click_x <= tile_x &&
 569                   event->y <= (tile_y + TILE_HEIGHT) && game->click_y >= tile_y) )
 570             {
 571                 group.tiles[group.num_tiles] = game->deck.tiles[i];
 572                 group.num_tiles++;
 573             }
 574         }
 575         printf("is run %d\n", tile_group_is_run_one(&group) );
 576         printf("is set %d\n", tile_group_is_set(&group) );
 577         for (i = 0; i < group.num_tiles; i++)
 578             tile_print(group.tiles[i]);
 579     }
 580
 581     game->current_tile = -1;
 582
 583     return TRUE;
 584 }
 585
 586 static gboolean on_button_motion_event (GtkWidget *widget, GdkEventMotion *event,
 587                                         game_t *game, cairo_t *cr)
 588 {
 589     if (game->current_tile == -1)
 590     {
 591         selection_box_t *box;
 592         box = &game->selection_box;
 593         box->visible = 1;
 594
 595         gtk_widget_queue_draw_area (widget, box->x - 1, box->y - 1, box->width + 1, box->height + 2);
 596
 597         box->width = event->x - box->x;
 598         box->height = event->y - box->y;
 599
 600         gtk_widget_queue_draw_area (widget, box->x - 1, box->y - 1, box->width + 1, box->height + 2);
 601     }
 602     else
 603     {
 604         tile_t *tile;
 605         tile = &game->deck.tiles[game->current_tile];
 606
 607         /* First, invalidate the region where the tile currently is. */
 608         gtk_widget_queue_draw_area (widget, tile->x - 1, tile->y - 1, TILE_WIDTH + 1, TILE_HEIGHT + 2);
 609
 610     /* Then, move the tile */
 611         tile->x = event->x - game->diff_x;
 612         tile->y = event->y - game->diff_y;
 613
 614     /* Finally, invalidate the region where the tile is now. */
 615         gtk_widget_queue_draw_area (widget, tile->x - 1, tile->y - 1, TILE_WIDTH + 1, TILE_HEIGHT + 2);
 616     }
 617     return TRUE;
 618 }
 619
 620 int main(int argc, char *argv[])
 621 {
 622     GtkWidget *window;
 623     game_t game;
 624
 625     srand(time(NULL));
 626
 627     gtk_init (&argc, &argv);
 628
 629     game_init(&game);
 630     deck_print(&game.deck);
 631     deck_spread(&game.deck);
 632     deck_deal(&game, &game.deck);
 633     //hand_print(&game, 0); //With Zero being passed, will print hand for player 1(players[0])
 634     //deck_print(&game.deck);
 635
 636     /* Create a new window */
 637     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 638     gtk_window_set_default_size (GTK_WINDOW (window),
 639                                  GAME_WINDOW_DEFAULT_WIDTH,
 640                                  GAME_WINDOW_DEFAULT_HEIGHT);
 641
 642     gtk_widget_set_events (window,
 643                            GDK_EXPOSURE_MASK |
 644                            GDK_KEY_PRESS_MASK |
 645                            GDK_BUTTON_MOTION_MASK |
 646                            GDK_BUTTON_PRESS_MASK |
 647                            GDK_BUTTON_RELEASE_MASK);
 648
 649     g_signal_connect (G_OBJECT (window), "delete_event",
 650                       G_CALLBACK (gtk_main_quit), NULL);
 651     g_signal_connect (G_OBJECT (window), "expose_event",
 652                       G_CALLBACK (on_expose_event), &game);
 653     g_signal_connect (G_OBJECT (window), "key_press_event",
 654                       G_CALLBACK (on_key_press_event), &game);
 655     g_signal_connect (G_OBJECT (window), "button_press_event",
 656                       G_CALLBACK (on_button_press_event), &game);
 657     g_signal_connect (G_OBJECT (window), "button_release_event",
 658                       G_CALLBACK (on_button_release_event), &game);
 659     g_signal_connect (G_OBJECT (window), "motion_notify_event",
 660                       G_CALLBACK (on_button_motion_event), &game);
 661
 662
 663     gtk_widget_show_all (window);
 664     gtk_main ();
 665
 666     return 0;
 667
 668 }