git.cworth.org Git - grrobot/blob - src/grrobot.c

   1 /* grrobot - Ricochet Robot using GTK+ and Xr
   2  *
   3  * Copyright © 2003 Carl Worth
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software
   6  * and its documentation for any purpose is hereby granted without
   7  * fee, provided that the above copyright notice appear in all copies
   8  * and that both that copyright notice and this permission notice
   9  * appear in supporting documentation, and that the name of Carl Worth
  10  * not be used in advertising or publicity pertaining to distribution
  11  * of the software without specific, written prior permission.
  12  * Carl Worth makes no representations about the suitability of this
  13  * software for any purpose.  It is provided "as is" without express
  14  * or implied warranty.
  15  *
  16  * CARL WORTH DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  17  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
  18  * NO EVENT SHALL CARL WORTH BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  19  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
  20  * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  21  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  22  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  23  *
  24  * Author: Carl Worth <carl@theworths.org>
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35 #include <gtk/gtk.h>
  36
  37 #include "grr_board_view.h"
  38 #include "grr_util.h"
  39 #include "args.h"
  40
  41 typedef struct grr_game {
  42     rr_client_t *client;
  43     rr_board_t *board;
  44
  45     GtkWidget *window;
  46     GtkWidget *board_view;
  47     GtkWidget *command_entry;
  48
  49     GtkTextBuffer *message_buffer;
  50     GtkWidget *message_view;
  51     int msg_id;
  52     int last_move_msg_id;
  53     rr_robot_t last_move_robot;
  54 } grr_game_t;
  55
  56 static int
  57 grr_game_printf (grr_game_t *game, const char *fmt, ...);
  58
  59 static int
  60 grr_game_vprintf (grr_game_t *game, const char *fmt, va_list ap);
  61
  62 static int
  63 grr_game_print (grr_game_t *game, const char *msg);
  64
  65 static int
  66 grr_game_start_gui (grr_game_t *game);
  67
  68 static void
  69 grr_game_read_notices (grr_game_t *game);
  70
  71 static GSource *
  72 grr_game_notices_source_new (grr_game_t *game);
  73
  74 int
  75 main (int argc, char **argv)
  76 {
  77     args_t args;
  78     rr_status_t status;
  79     grr_game_t game;
  80     GSource *source;
  81
  82     char *diagram;
  83
  84     gtk_init (&argc, &argv);
  85
  86     args_parse (&args, argc, argv);
  87
  88     game.client = rr_client_create (args.host, args.port, args.user);
  89     if (game.client == NULL) {
  90         fprintf (stderr, "Failed connecting to %s:%s as %s\n",
  91                  args.host, args.port, args.user);
  92         return 1;
  93     }
  94
  95     status = rr_client_join (game.client, args.game);
  96     if (status == RR_STATUS_NO_GAME) {
  97         status = rr_client_new (game.client, args.game);
  98     }
  99
 100     game.board = rr_board_create (16, 16);
 101     game.msg_id = 0;
 102     game.last_move_msg_id = 0;
 103     game.last_move_robot = RR_ROBOT_NONE;
 104
 105     source = grr_game_notices_source_new (&game);
 106     g_source_set_priority (source, GDK_PRIORITY_EVENTS);
 107     g_source_attach (source, NULL);
 108     g_source_unref (source);
 109
 110     rr_client_show (game.client, &diagram);
 111     rr_board_parse (game.board, diagram);
 112     free (diagram);
 113
 114     return grr_game_start_gui (&game);
 115 }
 116
 117 typedef struct _GrrNoticeSource {
 118     GSource source;
 119     grr_game_t *game;
 120 } GrrNoticeSource;
 121
 122 static gboolean
 123 grr_game_notices_prepare (GSource   *source,
 124                           gint      *timeout)
 125 {
 126     GrrNoticeSource *src = (GrrNoticeSource*)source;
 127     grr_game_t *game = src->game;
 128     gboolean retval;
 129
 130     GDK_THREADS_ENTER ();
 131     *timeout = -1;
 132     retval = rr_client_notice_pending (game->client);
 133     GDK_THREADS_LEAVE ();
 134
 135     return retval;
 136 }
 137
 138 static gboolean
 139 grr_game_notices_check (GSource     *source)
 140 {
 141     GrrNoticeSource *src = (GrrNoticeSource*)source;
 142     grr_game_t *game = src->game;
 143     gboolean retval;
 144
 145     GDK_THREADS_ENTER ();
 146     retval = rr_client_notice_pending (game->client);
 147     GDK_THREADS_LEAVE ();
 148
 149     return retval;
 150 }
 151
 152 static gboolean
 153 grr_game_notices_dispatch (GSource      *source,
 154                            GSourceFunc  callback,
 155                            gpointer     user_data)
 156 {
 157     GrrNoticeSource *src = (GrrNoticeSource*)source;
 158     grr_game_t *game = src->game;
 159
 160     grr_game_read_notices (game);
 161
 162     return TRUE;
 163 }
 164
 165 static GSourceFuncs game_notices_funcs = {
 166   grr_game_notices_prepare,
 167   grr_game_notices_check,
 168   grr_game_notices_dispatch,
 169   NULL
 170 };
 171
 172 static GSource *
 173 grr_game_notices_source_new (grr_game_t *game)
 174 {
 175     GSource *source = g_source_new (&game_notices_funcs, sizeof (GrrNoticeSource));
 176     GrrNoticeSource *src = (GrrNoticeSource*)source;
 177     src->game = game;
 178     return source;
 179 }
 180
 181 static void
 182 grr_game_read_notices (grr_game_t *game)
 183 {
 184     rr_board_t *board = game->board;
 185     rr_status_t status;
 186     rr_notice_t *notice;
 187
 188     while (rr_client_notice_pending (game->client)) {
 189         status = rr_client_next_notice (game->client, &notice);
 190         if (status) {
 191             if (status == RR_STATUS_EOF)
 192                 fprintf (stderr, "The server has disconnected, exiting.\n");
 193             else
 194                 fprintf (stderr, "Error during rr_client_next_notice: %s\n",
 195                          rr_status_str (status));
 196             gtk_exit (1);
 197         }
 198         if (!notice) {
 199             fprintf (stderr, "Missing notice\n");
 200             continue;
 201         }
 202
 203         switch (notice->type) {
 204         case RR_NOTICE_USER:
 205             grr_game_printf (game,
 206                              "\nGLOBAL: %s has connected.", notice->u.string);
 207             break;
 208         case RR_NOTICE_QUIT:
 209             grr_game_printf (game,
 210                              "\nGLOBAL: %s has disconnected.", notice->u.string);
 211             break;
 212         case RR_NOTICE_GAME:
 213             grr_game_printf (game,
 214                              "\nGLOBAL: New game available: %s.", notice->u.string);
 215             break;
 216         case RR_NOTICE_DISPOSE:
 217             grr_game_printf (game,
 218                              "\nGLOBAL: Game %s has been disposed.", notice->u.string);
 219             break;
 220         case RR_NOTICE_MESSAGE:
 221             grr_game_printf (game, "\n%s> %s",
 222                              notice->u.message.username,
 223                              notice->u.message.text);
 224             break;
 225         case RR_NOTICE_GAMESTATE:
 226             grr_game_printf (game, "\nGame state changed to: %s.",
 227                              rr_gamestate_str (notice->u.gamestate));
 228             break;
 229         case RR_NOTICE_TURN:
 230             grr_game_print (game, "\nNew round!");
 231             rr_board_set_goal_target (board, notice->u.target);
 232             gtk_widget_queue_draw (GTK_WIDGET (game->window));
 233             break;
 234         case RR_NOTICE_GAMEOVER:
 235         {
 236             char *diagram;
 237             grr_game_printf (game, "\nGame over. New game will begin now.");
 238             /* XXX: Can drop this when the BOARD NOTICE is added in the server */
 239             rr_client_show (game->client, &diagram);
 240             rr_board_parse (board, diagram);
 241             free (diagram);
 242             gtk_widget_queue_draw (GTK_WIDGET (game->window));
 243         }
 244         break;
 245         case RR_NOTICE_JOIN:
 246             grr_game_printf (game, "\nUser %s has joined the game.",
 247                              notice->u.string);
 248             break;
 249         case RR_NOTICE_WATCH:
 250             grr_game_printf (game, "\nUser %s has started watching the game.",
 251                              notice->u.string);
 252             break;
 253         case RR_NOTICE_PART:
 254             grr_game_printf (game, "\nUser %s has left the game.",
 255                              notice->u.string);
 256             break;
 257         case RR_NOTICE_BID:
 258             grr_game_printf (game, "\nUser %s bids %d.",
 259                              notice->u.bid.username,
 260                              notice->u.bid.number);
 261             break;
 262         case RR_NOTICE_REVOKE:
 263             grr_game_printf (game, "\nUser %s revokes previous bid.",
 264                              notice->u.string);
 265             break;
 266         case RR_NOTICE_ABANDON:
 267             grr_game_printf (game, "\nUser %s is willing to abandon this turn.",
 268                              notice->u.string);
 269             break;
 270         case RR_NOTICE_NOBID:
 271             grr_game_printf (game, "\nUser %s sees no point in bidding further this round",
 272                              notice->u.string);
 273             break;
 274         case RR_NOTICE_MOVE:
 275             if (game->msg_id == game->last_move_msg_id
 276                 && game->last_move_robot == notice->u.move.robot) {
 277                 game->last_move_msg_id = grr_game_printf (game, " %s",
 278                                  rr_direction_str (notice->u.move.direction));
 279             } else {
 280                 game->last_move_msg_id = grr_game_printf (game, "\nMove #%d: %s %s",
 281                                  notice->u.move.count,
 282                                  rr_robot_str (notice->u.move.robot),
 283                                  rr_direction_str (notice->u.move.direction));
 284                 game->last_move_robot = notice->u.move.robot;
 285             }
 286             break;
 287         case RR_NOTICE_UNDO:
 288             grr_game_print (game, "\nUNDO");
 289             break;
 290         case RR_NOTICE_RESET:
 291             grr_game_print (game, "\nRESET");
 292             break;
 293         case RR_NOTICE_SCORE:
 294             grr_game_printf (game, "\nScore for %s: %d.",
 295                              notice->u.bid.username,
 296                              notice->u.bid.number);
 297             break;
 298         case RR_NOTICE_ACTIVATE:
 299             grr_game_printf (game, "\nYour turn.",
 300                              notice->u.number);
 301             break;
 302         case RR_NOTICE_ACTIVE:
 303             grr_game_printf (game, "\nUser %s now active to demonstrate solution in %d moves.",
 304                                notice->u.bid.username,
 305                              notice->u.bid.number);
 306             break;
 307         case RR_NOTICE_TIMER:
 308             grr_game_printf (game, "\nTime remaining: %d seconds.",
 309                              notice->u.number);
 310             break;
 311         case RR_NOTICE_POSITION:
 312             rr_board_position_robot (board, notice->u.position.robot,
 313                                      notice->u.position.x, notice->u.position.y);
 314             gtk_widget_queue_draw (GTK_WIDGET (game->window));
 315             break;
 316         }
 317         free (notice);
 318     }
 319 }
 320
 321 static void
 322 grr_game_entry_callback (GtkWidget *widget,
 323                          grr_game_t *game)
 324 {
 325     rr_status_t status;
 326     const gchar *entry_text;
 327     char **response;
 328     int i;
 329
 330     entry_text = gtk_entry_get_text (GTK_ENTRY (game->command_entry));
 331
 332     status = rr_client_request (game->client, entry_text, &response);
 333     if (status) {
 334         grr_game_printf (game, "\nERROR: %s.", rr_status_str (status));
 335     } else {
 336         if (response[0]) {
 337             grr_game_print (game, "\n");
 338             for (i=0; response[i]; i++)
 339                 grr_game_printf (game, "%s ", response[i]);
 340         }
 341     }
 342
 343     gtk_entry_set_text (GTK_ENTRY (game->command_entry), "");
 344
 345 /* XXX: Huh? Why is this triggering valgrind?
 346     free (response);
 347 */
 348
 349 }
 350
 351 static int
 352 grr_game_printf (grr_game_t *game, const char *fmt, ...)
 353 {
 354     int msg_id;
 355
 356     va_list ap;
 357
 358     va_start (ap, fmt);
 359     msg_id = grr_game_vprintf (game, fmt, ap);
 360     va_end (ap);
 361
 362     return msg_id;
 363 }
 364
 365 static int
 366 grr_game_vprintf (grr_game_t *game, const char *fmt, va_list ap)
 367 {
 368     char *msg;
 369     int msg_id;
 370
 371     grr_sprintf_alloc_va (&msg, fmt, ap);
 372     if (msg == NULL)
 373         return 0;
 374
 375     msg_id = grr_game_print (game, msg);
 376
 377     free (msg);
 378
 379     return msg_id;
 380 }
 381
 382 static int
 383 grr_game_print (grr_game_t *game, const char *msg)
 384 {
 385     GtkTextIter iter;
 386     GtkTextMark *mark;
 387
 388     /* There might be a lighter way to do this, but this seems to
 389        work. */
 390
 391     gtk_text_buffer_get_end_iter (game->message_buffer, &iter);
 392
 393     mark = gtk_text_buffer_get_mark (game->message_buffer, "end");
 394
 395     gtk_text_buffer_move_mark (game->message_buffer, mark, &iter);
 396
 397     gtk_text_buffer_insert (game->message_buffer, &iter, msg, -1);
 398
 399     gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (game->message_view),
 400                                   mark, 0.0, TRUE, 0.0, 1.0);
 401
 402     return ++game->msg_id;
 403 }
 404
 405 static int
 406 grr_game_start_gui (grr_game_t *game)
 407 {
 408     GtkWidget *board_frame;
 409     GtkWidget *vpaned;
 410     GtkWidget *sw;
 411     GtkWidget *vbox;
 412     GtkWidget *window;
 413     GtkWidget *message_view;
 414     GtkWidget *command_entry;
 415
 416     game->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 417     window = game->window;
 418
 419     gtk_window_set_title (GTK_WINDOW (window), "Ricochet Robot");
 420     gtk_window_set_default_size (GTK_WINDOW (window), 512, 512);
 421
 422     g_signal_connect (G_OBJECT (window), "destroy",
 423                       G_CALLBACK (exit), NULL);
 424     gtk_container_set_border_width (GTK_CONTAINER (window), 0);
 425
 426     vbox = gtk_vbox_new (FALSE, 1);
 427     gtk_container_add (GTK_CONTAINER (window), vbox);
 428     {
 429         GtkTextIter iter;
 430         game->board_view = grr_board_view_new (game->board);
 431         grr_board_view_set_client (GRR_BOARD_VIEW (game->board_view), game->client);
 432         game->message_buffer = gtk_text_buffer_new (NULL);
 433         gtk_text_buffer_get_iter_at_offset (game->message_buffer,
 434                                             &iter, -1);
 435         gtk_text_buffer_create_mark (game->message_buffer,
 436                                      "end", &iter, FALSE);
 437         game->message_view = gtk_text_view_new_with_buffer (game->message_buffer);
 438         game->command_entry = gtk_entry_new ();
 439
 440         vpaned = gtk_vpaned_new ();
 441         gtk_container_set_border_width (GTK_CONTAINER (vpaned), 0);
 442         gtk_box_pack_start (GTK_BOX (vbox), vpaned,
 443                             TRUE, TRUE, 0);
 444         {
 445             board_frame = gtk_aspect_frame_new (NULL, 0.5, 0.5, 1.0, FALSE);
 446             gtk_paned_pack1 (GTK_PANED (vpaned), board_frame, TRUE, TRUE);
 447             {
 448                 gtk_container_add (GTK_CONTAINER (board_frame), game->board_view);
 449                 gtk_widget_show (game->board_view);
 450             }
 451             gtk_widget_show (board_frame);
 452
 453             sw = gtk_scrolled_window_new (NULL, NULL);
 454             gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 455                                             GTK_POLICY_NEVER,
 456                                             GTK_POLICY_AUTOMATIC);
 457             gtk_paned_pack2 (GTK_PANED (vpaned), sw, FALSE, TRUE);
 458             {
 459                 message_view = game->message_view;
 460                 gtk_text_view_set_editable (GTK_TEXT_VIEW (message_view), FALSE);
 461                 gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (message_view), FALSE);
 462                 gtk_container_add (GTK_CONTAINER (sw), message_view);
 463                 gtk_widget_show (message_view);
 464             }
 465             gtk_widget_show (sw);
 466         }
 467         gtk_widget_show (vpaned);
 468
 469         command_entry = game->command_entry;
 470         gtk_box_pack_end (GTK_BOX (vbox), command_entry,
 471                           FALSE, FALSE, 0);
 472         gtk_widget_show (command_entry);
 473         g_signal_connect (G_OBJECT (command_entry), "activate",
 474                           G_CALLBACK (grr_game_entry_callback),
 475                           (gpointer) game);
 476     }
 477     gtk_widget_show (vbox);
 478
 479     gtk_widget_show (window);
 480
 481     gtk_main ();
 482
 483     return 0;
 484 }