git.cworth.org Git - wordgame/blob - rack-fancy.c

   1 /*
   2  * Copyright © 2006 Carl Worth
   3  *
   4  * This program is free software; you can redistribute it and\/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2, or (at your option)
   7  * any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA."
  17  */
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <goocanvas.h>
  21 #include <sys/time.h>
  22 #include <time.h>
  23 #include <ctype.h>
  24 #include <math.h>
  25 #include <gdk/gdkkeysyms.h>
  26
  27 #include "word-game.h"
  28 #include "demo-item.h"
  29
  30 #define RACK_DICT_ENTRY_FOUND (1<<1)
  31 #define MAX_TILES 7
  32
  33 typedef struct _tile
  34 {
  35     char letter;
  36     int rack_index;
  37     int x, y;
  38     GooCanvasItem *item;
  39     gboolean guessed;
  40 } tile_t;
  41
  42 typedef struct _rack
  43 {
  44     tile_t *tiles[MAX_TILES];
  45     int num_tiles;
  46     char guess[MAX_TILES+1];
  47     int guess_length;
  48     dict_t *solution;
  49     GooCanvasItem *solution_item;
  50 } rack_t;
  51
  52 #define LETTER_SIZE 60
  53 #define LETTER_PAD 5
  54
  55 static void
  56 guess_tile_position (int i, int *x, int *y)
  57 {
  58     *x = 20 + i * (LETTER_SIZE + LETTER_PAD);
  59     *y = LETTER_PAD;
  60 }
  61
  62 static void
  63 rack_tile_position (int i, int *x, int *y)
  64 {
  65     guess_tile_position (i, x, y);
  66     *y += (LETTER_SIZE + LETTER_PAD);
  67 }
  68
  69 typedef struct _dict_paint_cursor
  70 {
  71     cairo_t *cr;
  72     int line_height;
  73     int x;
  74     int y;
  75     int max_column_width;
  76     int max_y;
  77 } dict_paint_cursor_t;
  78
  79 static void
  80 dict_paint_action (void *closure, char *word, dict_entry_t *entry)
  81 {
  82     dict_paint_cursor_t *cursor = closure;
  83     cairo_t *cr = cursor->cr;
  84     double new_x, new_y;
  85
  86     if (strlen (word) < 3)
  87         return;
  88
  89     cairo_move_to (cr, cursor->x, cursor->y);
  90     if (*entry & RACK_DICT_ENTRY_FOUND) {
  91         cairo_show_text (cr, word);
  92     } else {
  93         int i, length = strlen (word);
  94         for (i = 0; i < length; i++)
  95             cairo_show_text (cr, "_");
  96     }
  97     cairo_get_current_point (cr, &new_x, &new_y);
  98     if (new_x > cursor->max_column_width)
  99         cursor->max_column_width = new_x;
 100     cursor->y += cursor->line_height;
 101     if (cursor->y > cursor->max_y) {
 102         cursor->x = cursor->max_column_width + cursor->line_height / 2;
 103         cursor->y = 0;
 104     }
 105 }
 106
 107 #define SOLUTION_FONT_SIZE      12
 108 #define SOLUTION_LINE_HEIGHT    (1.5 * SOLUTION_FONT_SIZE)
 109
 110 static void
 111 dict_paint (cairo_t *cr, void *closure, double width, double height)
 112 {
 113     dict_t *dict = closure;
 114     dict_paint_cursor_t cursor;
 115
 116     cairo_save (cr);
 117     cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* black */
 118
 119     cursor.cr = cr;
 120
 121     cairo_select_font_face (cr, "mono", 0, 0);
 122     cairo_set_font_size (cr, SOLUTION_FONT_SIZE);
 123     cursor.line_height = SOLUTION_LINE_HEIGHT;
 124
 125     cursor.x = 0;
 126     cursor.y = 0;
 127
 128     cursor.max_column_width = 0;
 129     cursor.max_y = height;
 130
 131     dict_for_each_by_length (dict,
 132                              dict_paint_action,
 133                              &cursor);
 134
 135     cairo_restore (cr);
 136 }
 137
 138 static void
 139 tile_paint (cairo_t *cr, void *closure, double width, double height)
 140 {
 141     tile_t *tile = closure;
 142
 143     cairo_pattern_t *gradient;
 144     cairo_text_extents_t extents;
 145     int rad = (int) MIN (width / 2, height / 2);
 146     int cx = width / 2;
 147     int cy = cx;
 148     int tx, ty;
 149     double spot_angle = M_PI / 4.0;
 150     double spot_rad = rad / 2.0;
 151     char string[2];
 152
 153     cairo_save (cr);
 154
 155     gradient = cairo_pattern_create_radial (cx - spot_rad * cos (spot_angle),
 156                                             cy - spot_rad * sin (spot_angle),
 157                                             0.0,
 158                                             cx - spot_rad * cos (spot_angle),
 159                                             cy - spot_rad * sin (spot_angle),
 160                                             rad + spot_rad);
 161     cairo_pattern_add_color_stop_rgb (gradient, 0.0, 1.0, 1.0, 1.0);
 162     cairo_pattern_add_color_stop_rgb (gradient, 1.0, 0.33, 0.33, 0.33);
 163
 164     cairo_set_source (cr, gradient);
 165
 166     cairo_arc (cr,
 167                cx, cy,
 168                rad, 0, 2 * M_PI);
 169
 170     cairo_fill (cr);
 171
 172     cairo_select_font_face (cr, "mono",
 173                             CAIRO_FONT_SLANT_NORMAL,
 174                             CAIRO_FONT_WEIGHT_BOLD);
 175     cairo_set_font_size (cr, 1.8 * rad);
 176
 177     string[0] = tile->letter;
 178     string[1] = '\0';
 179     cairo_text_extents (cr, string, &extents);
 180     tx = cx - extents.width / 2 - extents.x_bearing;
 181     ty = cy - extents.height / 2 - extents.y_bearing;
 182
 183     cairo_set_source_rgb (cr, 0.7, 0.7, 0.7);
 184     cairo_move_to (cr, tx + 1, ty + 1);
 185     cairo_show_text (cr, string);
 186
 187     cairo_set_source_rgb (cr, 0.33, 0.33, 0.33);
 188     cairo_move_to (cr, tx - 1, ty - 1);
 189     cairo_show_text (cr, string);
 190
 191     cairo_set_source_rgb (cr, 0.2, 0.3, 0.8);
 192     cairo_move_to (cr, tx, ty);
 193     cairo_show_text (cr, string);
 194
 195     cairo_restore (cr);
 196 }
 197
 198 static void
 199 tile_glide_to (tile_t *tile, int x, int y)
 200 {
 201     goo_canvas_item_animate (tile->item, x, y,
 202                              1.0, 0,
 203                              500, 40,
 204                              GOO_CANVAS_ANIMATE_FREEZE);
 205     tile->x = x;
 206     tile->y = y;
 207 }
 208
 209 static tile_t *
 210 tile_create (GooCanvasItem *parent,
 211              char letter, int rack_index)
 212 {
 213     tile_t *tile;
 214
 215     tile = g_malloc (sizeof (tile_t));
 216     tile->letter = tolower (letter);
 217     tile->rack_index = rack_index;
 218     rack_tile_position (rack_index, &tile->x, &tile->y);
 219     tile->item = goo_demo_item_new (parent,
 220                                     tile->x, tile->y,
 221                                     LETTER_SIZE, LETTER_SIZE,
 222                                     tile_paint,
 223                                     tile, NULL);
 224
 225     tile->guessed = FALSE;
 226
 227     return tile;
 228 }
 229
 230 static gboolean
 231 on_delete_event (GtkWidget *window,
 232                  GdkEvent  *event,
 233                  gpointer   unused_data)
 234 {
 235     exit (0);
 236 }
 237
 238 static int
 239 rand_within (int num_values)
 240 {
 241     return (int) ((double) num_values * (rand() / (RAND_MAX + 1.0)));
 242 }
 243
 244 static void
 245 shuffle (int *array, int length)
 246 {
 247     int i, r, tmp;
 248
 249     for (i = 0; i < length; i++)
 250     {
 251         r = i + rand_within (length - i);
 252         tmp = array[i];
 253         array[i] = array[r];
 254         array[r] = tmp;
 255     }
 256 }
 257
 258 static void
 259 rack_init (rack_t       *rack,
 260            dict_t       *solution)
 261 {
 262     int i;
 263
 264     for (i = 0; i < MAX_TILES; i++)
 265         rack->tiles[i] = NULL;
 266     rack->num_tiles = 0;
 267
 268     rack->guess_length = 0;
 269     rack->solution = solution;
 270     rack->solution_item = NULL;
 271 }
 272
 273 static void
 274 rack_create_tiles (rack_t       *rack,
 275                    GooCanvas    *canvas,
 276                    char         *word)
 277 {
 278     int i;
 279
 280     GooCanvasItem *root = goo_canvas_get_root_item (canvas);
 281
 282     for (i = 0; i < MIN (MAX_TILES, strlen (word)); i++)
 283         rack->tiles[i] = tile_create (root, word[i], i);
 284     rack->num_tiles = i;
 285 }
 286
 287 static gboolean
 288 rack_shuffle (rack_t *rack)
 289 {
 290     int indices[MAX_TILES];
 291     int i, x, y;
 292
 293     for (i = 0; i < rack->num_tiles; i++)
 294         indices[i] = i;
 295
 296     shuffle (indices, rack->num_tiles);
 297
 298     for (i = 0; i < rack->num_tiles; i++) {
 299         rack->tiles[i]->rack_index = indices[i];
 300         rack_tile_position (indices[i], &x, &y);
 301         tile_glide_to (rack->tiles[i], x, y);
 302     }
 303
 304     return TRUE;
 305 }
 306
 307 static void
 308 rack_return_tile (rack_t *rack, tile_t *tile)
 309 {
 310     int x, y;
 311
 312     rack_tile_position (tile->rack_index, &x, &y);
 313     tile_glide_to (tile, x, y);
 314     tile->guessed = FALSE;
 315     rack->guess_length--;
 316     rack->guess[rack->guess_length] = '\0';
 317 }
 318
 319 static void
 320 rack_return_all (rack_t *rack)
 321 {
 322     int i;
 323
 324     for (i = 0; i < rack->num_tiles; i++) {
 325         if (rack->tiles[i]->guessed)
 326             rack_return_tile (rack, rack->tiles[i]);
 327     }
 328     rack->guess_length = 0;
 329     rack->guess[0] = '\0';
 330 }
 331
 332 static gboolean
 333 on_key_press_event (GtkWidget   *widget,
 334                     GdkEventKey *event,
 335                     gpointer     user_data)
 336 {
 337     int i, x, y;
 338     char guess_letter;
 339     rack_t *rack = user_data;
 340
 341     if (event->keyval == GDK_Return) {
 342         dict_entry_t *entry;
 343         if (rack->guess_length >= 3) {
 344             entry = dict_lookup (rack->solution, rack->guess);
 345             if (DICT_ENTRY_IS_WORD (entry)) {
 346                 *entry = *entry | RACK_DICT_ENTRY_FOUND;
 347                 goo_canvas_item_simple_changed (GOO_CANVAS_ITEM_SIMPLE (rack->solution_item), FALSE);
 348             }
 349         }
 350         rack_return_all (rack);
 351         return TRUE;
 352     }
 353
 354     if (event->keyval == GDK_space) {
 355         rack_return_all (rack);
 356         rack_shuffle (rack);
 357         return TRUE;
 358     }
 359
 360     if (event->keyval == GDK_BackSpace) {
 361         gboolean found = FALSE;
 362         int found_index;
 363         x = 0;
 364         for (i = 0; i < rack->num_tiles; i++) {
 365             /* XXX: evil stuff here... please refactor a lot */
 366             if (rack->guess[rack->guess_length-1] == rack->tiles[i]->letter &&
 367                 rack->tiles[i]->guessed &&
 368                 rack->tiles[i]->x > x)
 369             {
 370                 found = TRUE;
 371                 found_index = i;
 372             }
 373         }
 374         if (found) {
 375             rack_return_tile (rack, rack->tiles[found_index]);
 376             return TRUE;
 377         }
 378         return FALSE;
 379     }
 380
 381     /* XXX: event->string is deprecated, but the non-deprecated
 382      * input-method stuff (GtkIMContext) is extremely non-obvious to
 383      * use. */
 384     guess_letter = tolower (event->string[0]);
 385     for (i = 0; i < rack->num_tiles; i++) {
 386         if (guess_letter == rack->tiles[i]->letter &&
 387             ! rack->tiles[i]->guessed)
 388         {
 389             guess_tile_position (rack->guess_length, &x, &y);
 390             tile_glide_to (rack->tiles[i], x, y);
 391             rack->tiles[i]->guessed = TRUE;
 392             rack->guess[rack->guess_length++] = guess_letter;
 393             rack->guess[rack->guess_length] = '\0';
 394             return TRUE;
 395         }
 396     }
 397
 398     return FALSE;
 399 }
 400
 401 static GtkWidget *
 402 create_window (rack_t *rack)
 403 {
 404     GtkWidget *window, *scrolled_window;
 405
 406     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 407     gtk_window_set_default_size (GTK_WINDOW (window), 500, 500);
 408     gtk_widget_show (window);
 409     g_signal_connect (window, "delete_event",
 410                       (GtkSignalFunc) on_delete_event, NULL);
 411
 412     gtk_widget_add_events (window, GDK_KEY_PRESS_MASK);
 413     g_signal_connect (window, "key_press_event",
 414                       (GtkSignalFunc) on_key_press_event, rack);
 415
 416     scrolled_window = gtk_scrolled_window_new (NULL, NULL);
 417     gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
 418                                          GTK_SHADOW_IN);
 419     gtk_scrolled_window_set_policy  (GTK_SCROLLED_WINDOW (scrolled_window),
 420                                      GTK_POLICY_AUTOMATIC,
 421                                      GTK_POLICY_AUTOMATIC);
 422     gtk_widget_show (scrolled_window);
 423     gtk_container_add (GTK_CONTAINER (window), scrolled_window);
 424
 425     return scrolled_window;
 426 }
 427
 428 static GooCanvas *
 429 create_canvas (GtkWidget *parent, rack_t *rack)
 430 {
 431     GtkWidget *canvas;
 432     GooCanvasItem *root;
 433
 434     canvas = goo_canvas_new ();
 435     gtk_widget_set_size_request (canvas, 400, 400);
 436     goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0, 400, 400);
 437     gtk_widget_show (canvas);
 438     gtk_container_add (GTK_CONTAINER (parent), canvas);
 439
 440     root = goo_canvas_get_root_item (GOO_CANVAS (canvas));
 441
 442     rack->solution_item = goo_demo_item_new (root,
 443                                              LETTER_PAD + SOLUTION_LINE_HEIGHT,
 444                                              LETTER_PAD + 2 * (LETTER_SIZE + 2 * LETTER_PAD),
 445                                              400, 400 - (2 * (LETTER_SIZE + 2 * LETTER_PAD)),
 446                                              dict_paint, rack->solution,
 447                                              NULL);
 448
 449     return GOO_CANVAS (canvas);
 450 }
 451
 452 int
 453 main (int argc, char *argv[])
 454 {
 455     dict_t dict, solution;
 456     struct timeval tv;
 457     bag_t bag;
 458     rack_t rack;
 459     char word[8];
 460     int i;
 461     char *draw;
 462     GtkWidget *window;
 463     GooCanvas *canvas;
 464
 465     gettimeofday (&tv, NULL);
 466     srand (tv.tv_sec ^ tv.tv_usec);
 467
 468     bag_init (&bag);
 469     bag_shuffle (&bag);
 470
 471     /* Keep drawing until we get 7 non-blank tiles */
 472     i = 0;
 473     draw = bag.tiles;
 474     while (i < 7) {
 475         if (*draw != '?')
 476             word[i++] = toupper (*draw);
 477         draw++;
 478     }
 479
 480     dict_init (&dict);
 481     dict_add_words_from_file (&dict, "words.txt");
 482
 483     dict_init (&solution);
 484     subanagram_expand (word, &dict, &solution);
 485
 486     gtk_init (&argc, &argv);
 487
 488     rack_init (&rack, &solution);
 489
 490     window = create_window (&rack);
 491
 492     canvas = create_canvas (window, &rack);
 493
 494     rack_create_tiles (&rack, canvas, word);
 495
 496     gtk_main ();
 497
 498     return 0;
 499 }