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 MAX_TILES 7
  31
  32 typedef struct _tile
  33 {
  34     char letter;
  35     int rack_index;
  36     int x, y;
  37     int size;
  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 } rack_t;
  47
  48 static rack_t the_rack;
  49
  50 static char the_guess[MAX_TILES];
  51 static int the_guess_index = 0;
  52
  53 #define LETTER_SIZE 60
  54 #define LETTER_PAD 5
  55
  56 static void
  57 rack_tile_position (int i, int *x, int *y)
  58 {
  59     *x = 20 + i * (LETTER_SIZE + LETTER_PAD);
  60     *y = 85;
  61 }
  62
  63 static void
  64 guess_tile_position (int i, int *x, int *y)
  65 {
  66     rack_tile_position (i, x, y);
  67     *y -= (LETTER_SIZE + LETTER_PAD);
  68 }
  69
  70 static void
  71 tile_paint (cairo_t *cr, void *closure)
  72 {
  73     tile_t *tile = closure;
  74
  75     cairo_pattern_t *gradient;
  76     cairo_text_extents_t extents;
  77     int rad = (int) (tile->size / 2);
  78     int cx = tile->size / 2;
  79     int cy = cx;
  80     int tx, ty;
  81     double spot_angle = M_PI / 4.0;
  82     double spot_rad = rad / 2.0;
  83     char string[2];
  84
  85     cairo_save (cr);
  86
  87     gradient = cairo_pattern_create_radial (cx - spot_rad * cos (spot_angle),
  88                                             cy - spot_rad * sin (spot_angle),
  89                                             0.0,
  90                                             cx - spot_rad * cos (spot_angle),
  91                                             cy - spot_rad * sin (spot_angle),
  92                                             rad + spot_rad);
  93     cairo_pattern_add_color_stop_rgb (gradient, 0.0, 1.0, 1.0, 1.0);
  94     cairo_pattern_add_color_stop_rgb (gradient, 1.0, 0.33, 0.33, 0.33);
  95
  96     cairo_set_source (cr, gradient);
  97
  98     cairo_arc (cr,
  99                cx, cy,
 100                rad, 0, 2 * M_PI);
 101
 102     cairo_fill (cr);
 103
 104     cairo_select_font_face (cr, "mono",
 105                             CAIRO_FONT_SLANT_NORMAL,
 106                             CAIRO_FONT_WEIGHT_BOLD);
 107     cairo_set_font_size (cr, 1.8 * rad);
 108
 109     string[0] = tile->letter;
 110     string[1] = '\0';
 111     cairo_text_extents (cr, string, &extents);
 112     tx = cx - extents.width / 2 - extents.x_bearing;
 113     ty = cy - extents.height / 2 - extents.y_bearing;
 114
 115     cairo_set_source_rgb (cr, 0.7, 0.7, 0.7);
 116     cairo_move_to (cr, tx + 1, ty + 1);
 117     cairo_show_text (cr, string);
 118
 119     cairo_set_source_rgb (cr, 0.33, 0.33, 0.33);
 120     cairo_move_to (cr, tx - 1, ty - 1);
 121     cairo_show_text (cr, string);
 122
 123     cairo_set_source_rgb (cr, 0.2, 0.3, 0.8);
 124     cairo_move_to (cr, tx, ty);
 125     cairo_show_text (cr, string);
 126
 127     cairo_restore (cr);
 128 }
 129
 130 static void
 131 tile_move_to (tile_t *tile, int x, int y)
 132 {
 133     cairo_matrix_t matrix;
 134
 135     cairo_matrix_init_translate (&matrix, x, y);
 136     goo_canvas_item_set_transform (tile->item, &matrix);
 137 }
 138
 139 static void
 140 tile_glide_to (tile_t *tile, int x, int y)
 141 {
 142     goo_canvas_item_animate (tile->item, x, y,
 143                              1.0, 0,
 144                              500, 40,
 145                              GOO_CANVAS_ANIMATE_FREEZE);
 146     tile->x = x;
 147     tile->y = y;
 148 }
 149
 150 static tile_t *
 151 tile_create (GooCanvasItem *parent,
 152              char letter, int rack_index)
 153 {
 154     tile_t *tile;
 155
 156     tile = g_malloc (sizeof (tile_t));
 157     tile->letter = tolower (letter);
 158     tile->rack_index = rack_index;
 159     rack_tile_position (rack_index, &tile->x, &tile->y);
 160     tile->size = LETTER_SIZE;
 161     tile->item = goo_demo_item_new (parent,
 162                                     tile->size,
 163                                     tile_paint,
 164                                     tile);
 165
 166     tile_move_to (tile, tile->x, tile->y);
 167
 168     tile->guessed = FALSE;
 169
 170     return tile;
 171 }
 172
 173 static gboolean
 174 on_delete_event (GtkWidget *window,
 175                  GdkEvent  *event,
 176                  gpointer   unused_data)
 177 {
 178     exit (0);
 179 }
 180
 181 static int
 182 rand_within (int num_values)
 183 {
 184     return (int) ((double) num_values * (rand() / (RAND_MAX + 1.0)));
 185 }
 186
 187 static void
 188 shuffle (int *array, int length)
 189 {
 190     int i, r, tmp;
 191
 192     for (i = 0; i < length; i++)
 193     {
 194         r = i + rand_within (length - i);
 195         tmp = array[i];
 196         array[i] = array[r];
 197         array[r] = tmp;
 198     }
 199 }
 200
 201 static void
 202 rack_init (rack_t *rack, GooCanvasItem *parent, char *word)
 203 {
 204     int i;
 205
 206     for (i = 0; i < MIN (MAX_TILES, strlen (word)); i++)
 207         rack->tiles[i] = tile_create (parent, word[i], i);
 208     rack->num_tiles = i;
 209     while (i < MAX_TILES)
 210         rack->tiles[i] = NULL;
 211 }
 212
 213 static gboolean
 214 rack_shuffle (rack_t *rack)
 215 {
 216     int indices[MAX_TILES];
 217     int i, x, y;
 218
 219     for (i = 0; i < rack->num_tiles; i++)
 220         indices[i] = i;
 221
 222     shuffle (indices, rack->num_tiles);
 223
 224     for (i = 0; i < rack->num_tiles; i++) {
 225         rack->tiles[i]->rack_index = indices[i];
 226         rack_tile_position (indices[i], &x, &y);
 227         tile_glide_to (rack->tiles[i], x, y);
 228     }
 229
 230     return TRUE;
 231 }
 232
 233 static gboolean
 234 on_key_press_event (GtkWidget   *widget,
 235                     GdkEventKey *event,
 236                     gpointer     user_data)
 237 {
 238     int i, x, y;
 239     char guess_letter;
 240     rack_t *rack = user_data;
 241
 242     if (event->keyval == GDK_space) {
 243         for (i = 0; i < rack->num_tiles; i++) {
 244             if (rack->tiles[i]->guessed) {
 245                 rack_tile_position (rack->tiles[i]->rack_index, &x, &y);
 246                 tile_glide_to (rack->tiles[i], x, y);
 247                 rack->tiles[i]->guessed = FALSE;
 248             }
 249         }
 250         the_guess_index = 0;
 251         rack_shuffle (rack);
 252         return TRUE;
 253     }
 254
 255     if (event->keyval == GDK_BackSpace) {
 256         gboolean found = FALSE;
 257         int found_index;
 258         x = 0;
 259         for (i = 0; i < rack->num_tiles; i++) {
 260             /* XXX: evil stuff here... please refactor a lot */
 261             if (the_guess[the_guess_index-1] == rack->tiles[i]->letter &&
 262                 rack->tiles[i]->guessed &&
 263                 rack->tiles[i]->x > x)
 264             {
 265                 found = TRUE;
 266                 found_index = i;
 267             }
 268         }
 269         if (found) {
 270             rack_tile_position (rack->tiles[found_index]->rack_index, &x, &y);
 271             tile_glide_to (rack->tiles[found_index], x, y);
 272             rack->tiles[found_index]->guessed = FALSE;
 273             the_guess_index--;
 274             return TRUE;
 275         }
 276         return FALSE;
 277     }
 278
 279     /* XXX: event->string is deprecated, but the non-deprecated
 280      * input-method stuff (GtkIMContext) is extremely non-obvious to
 281      * use. */
 282     guess_letter = tolower (event->string[0]);
 283     for (i = 0; i < rack->num_tiles; i++) {
 284         if (guess_letter == rack->tiles[i]->letter &&
 285             ! rack->tiles[i]->guessed)
 286         {
 287             guess_tile_position (the_guess_index, &x, &y);
 288             tile_glide_to (rack->tiles[i], x, y);
 289             rack->tiles[i]->guessed = TRUE;
 290             the_guess[the_guess_index++] = guess_letter;
 291             return TRUE;
 292         }
 293     }
 294
 295     return FALSE;
 296 }
 297
 298 static GtkWidget *
 299 create_window (void)
 300 {
 301     GtkWidget *window, *scrolled_window;
 302
 303     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 304     gtk_window_set_default_size (GTK_WINDOW (window), 500, 500);
 305     gtk_widget_show (window);
 306     g_signal_connect (window, "delete_event",
 307                       (GtkSignalFunc) on_delete_event, NULL);
 308
 309     gtk_widget_add_events (window, GDK_KEY_PRESS_MASK);
 310     g_signal_connect (window, "key_press_event",
 311                       (GtkSignalFunc) on_key_press_event, &the_rack);
 312
 313     scrolled_window = gtk_scrolled_window_new (NULL, NULL);
 314     gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
 315                                          GTK_SHADOW_IN);
 316     gtk_scrolled_window_set_policy  (GTK_SCROLLED_WINDOW (scrolled_window),
 317                                      GTK_POLICY_AUTOMATIC,
 318                                      GTK_POLICY_AUTOMATIC);
 319     gtk_widget_show (scrolled_window);
 320     gtk_container_add (GTK_CONTAINER (window), scrolled_window);
 321
 322     return scrolled_window;
 323 }
 324
 325 static void
 326 create_canvas (GtkWidget *parent, char *word)
 327 {
 328     GtkWidget *canvas;
 329     GooCanvasItem *root;
 330
 331     canvas = goo_canvas_new ();
 332     gtk_widget_set_size_request (canvas, 400, 400);
 333     goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0, 400, 400);
 334     gtk_widget_show (canvas);
 335     gtk_container_add (GTK_CONTAINER (parent), canvas);
 336
 337     root = goo_canvas_get_root_item (GOO_CANVAS (canvas));
 338
 339     rack_init (&the_rack, root, word);
 340 }
 341
 342 int
 343 main (int argc, char *argv[])
 344 {
 345     struct timeval tv;
 346     bag_t bag;
 347     char rack[8];
 348     int i;
 349     GtkWidget *window;
 350
 351     gettimeofday (&tv, NULL);
 352     srand (tv.tv_sec ^ tv.tv_usec);
 353
 354     bag_init (&bag);
 355     bag_shuffle (&bag);
 356
 357     memcpy (rack, bag.tiles, 7);
 358     rack[7] = '\0';
 359
 360     for (i = 0; i < 7; i++)
 361         rack[i] = toupper (rack[i]);
 362
 363     gtk_init (&argc, &argv);
 364     window = create_window ();
 365
 366     create_canvas (window, rack);
 367
 368     gtk_main ();
 369
 370     return 0;
 371 }