git.cworth.org Git - loudgame/blob - lg-set.c

   1 /*
   2  * Copyright (C) 2008 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 3 of the License, or
   7  * (at your option) 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, see http://www.gnu.org/licenses/ .
  16  *
  17  * Author: Carl Worth <cworth@cworth.org>
  18  */
  19
  20 #include "loudgame.h"
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <math.h>
  27 #include <time.h>
  28 #include <ctype.h>
  29
  30 #include <assert.h>
  31
  32 #define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
  33
  34 #define NUM_ATTRIBUTES 4
  35 #define NUM_VALUES 3
  36
  37 char *attribute_names[NUM_ATTRIBUTES] = {
  38     "number", "color", "shading", "symbol"
  39 };
  40
  41 typedef enum { ATTRIBUTE_INDEX_NUMBER,
  42                ATTRIBUTE_INDEX_COLOR,
  43                ATTRIBUTE_INDEX_SHADING,
  44                ATTRIBUTE_INDEX_SYMBOL } attribute_index_t;
  45
  46 char *attribute_values[NUM_ATTRIBUTES][NUM_VALUES] = {
  47     { "1", "2", "3" },
  48     { "red", "green", "purple" },
  49     { "solid", "open", "striped" },
  50     { "oval", "squiggle", "diamond" }
  51 };
  52
  53 typedef enum { COLOR_RED, COLOR_GREEN, COLOR_PURPLE } color_t;
  54 typedef enum { SHADING_OPEN, SHADING_STRIPED, SHADING_SOLID } shading_t;
  55 typedef enum { SYMBOL_OVAL, SYMBOL_SQUIGGLE, SYMBOL_DIAMOND } symbol_t;
  56
  57 typedef struct card {
  58     int attributes[NUM_ATTRIBUTES];
  59 } card_t;
  60
  61 #define DECK_MAX_CARDS ((int) (pow (NUM_VALUES, NUM_ATTRIBUTES)))
  62 typedef struct deck {
  63     int num_cards;
  64     card_t cards[DECK_MAX_CARDS];
  65 } deck_t;
  66
  67 typedef struct slot {
  68     int has_card;
  69     card_t card;
  70     int selected;
  71 } slot_t;
  72
  73 #define BOARD_COLS 3
  74 #define BOARD_ROWS 4
  75 #define BOARD_MAX_SLOTS (BOARD_COLS * BOARD_ROWS)
  76 typedef struct board {
  77     int num_slots;
  78     slot_t slots[BOARD_MAX_SLOTS];
  79     int sets_possible;
  80 } board_t;
  81
  82 typedef struct _set_game {
  83     loudgame_t lg;
  84     deck_t deck;
  85     board_t board;
  86 } set_game_t;
  87
  88 static void
  89 board_count_sets_possible (board_t *board);
  90
  91 static int
  92 set_game_shuffle (set_game_t *game);
  93
  94 static void
  95 set_game_new_game (set_game_t *game);
  96
  97 static int
  98 attribute_all_same (card_t *cards, int num_cards, int attr)
  99 {
 100     int i, value;
 101
 102     if (num_cards == 0)
 103         return 1;
 104
 105     value = cards[0].attributes[attr];
 106
 107     for (i = 1; i < num_cards; i++)
 108         if (cards[i].attributes[attr] != value)
 109             return 0;
 110
 111     return 1;
 112 }
 113
 114 static int
 115 attribute_all_different (card_t *cards, int num_cards, int attr)
 116 {
 117     int i, seen[NUM_VALUES];
 118
 119     if (num_cards == 0)
 120         return 1;
 121
 122     memset (seen, 0, sizeof (seen));
 123
 124     for (i = 0; i < num_cards; i++) {
 125         if (seen[cards[i].attributes[attr]])
 126             return 0;
 127         seen[cards[i].attributes[attr]] = 1;
 128     }
 129
 130     return 1;
 131 }
 132
 133 static int
 134 is_set (card_t *cards, int num_cards)
 135 {
 136     int attr;
 137
 138     for (attr = 0; attr < NUM_ATTRIBUTES; attr++)
 139         if (! attribute_all_same (cards, num_cards, attr) &&
 140             ! attribute_all_different (cards, num_cards, attr))
 141         {
 142             return 0;
 143         }
 144
 145     return 1;
 146 }
 147
 148 static void
 149 deck_shuffle (deck_t *deck)
 150 {
 151     int i, r;
 152     card_t tmp;
 153
 154     assert (deck->num_cards <= DECK_MAX_CARDS);
 155
 156     for (i=deck->num_cards - 1; i>=0; i--) {
 157         r = (int) i * (rand() / (RAND_MAX + 1.0));
 158         assert (r >= 0);
 159         assert (r <= i);
 160         tmp = deck->cards[i];
 161         deck->cards[i] = deck->cards[r];
 162         deck->cards[r] = tmp;
 163     }
 164 }
 165
 166 static void
 167 deck_init (deck_t *deck)
 168 {
 169     int card;
 170     int number;
 171     color_t color;
 172     shading_t shading;
 173     symbol_t symbol;
 174
 175     card = 0;
 176     for (number = 0; number < NUM_VALUES; number++)
 177         for (color = 0; color < NUM_VALUES; color++)
 178             for (shading = 0; shading < NUM_VALUES; shading++)
 179                 for (symbol = 0; symbol < NUM_VALUES; symbol++) {
 180                     deck->cards[card].attributes[ATTRIBUTE_INDEX_NUMBER] = number;
 181                     deck->cards[card].attributes[ATTRIBUTE_INDEX_COLOR] = color;
 182                     deck->cards[card].attributes[ATTRIBUTE_INDEX_SHADING] = shading;
 183                     deck->cards[card].attributes[ATTRIBUTE_INDEX_SYMBOL] = symbol;
 184                     card++;
 185                 }
 186     deck->num_cards = card;
 187
 188     deck_shuffle (deck);
 189 }
 190
 191 static void
 192 board_count_sets_possible (board_t *board)
 193 {
 194     int i, j, k;
 195     int sets_possible = 0;
 196     card_t cards[3];
 197
 198     for (i = 0; i < board->num_slots; i++) {
 199         if (! board->slots[i].has_card)
 200             continue;
 201         for (j = i+1; j < board->num_slots; j++) {
 202             if (! board->slots[j].has_card)
 203                 continue;
 204             for (k = j+1; k < board->num_slots; k++) {
 205                 if (! board->slots[k].has_card)
 206                     continue;
 207                 cards[0] = board->slots[i].card;
 208                 cards[1] = board->slots[j].card;
 209                 cards[2] = board->slots[k].card;
 210                 if (is_set (cards, 3))
 211                     sets_possible++;
 212             }
 213         }
 214     }
 215
 216     board->sets_possible = sets_possible;
 217 }
 218
 219 static void
 220 board_init (board_t *board)
 221 {
 222     int i;
 223     board->num_slots = BOARD_MAX_SLOTS;
 224     for (i=0; i < board->num_slots; i++) {
 225         board->slots[i].has_card = 0;
 226         board->slots[i].selected = 0;
 227     }
 228
 229     board_count_sets_possible (board);
 230 }
 231
 232 static void
 233 deal (deck_t *deck, board_t *board)
 234 {
 235     int i;
 236
 237     for (i=0; i < board->num_slots; i++)
 238         if (! board->slots[i].has_card) {
 239             if (deck->num_cards > 0) {
 240                 board->slots[i].card = deck->cards[deck->num_cards-- -1];
 241                 board->slots[i].has_card = 1;
 242             }
 243         }
 244
 245     board_count_sets_possible (board);
 246 }
 247
 248 static void
 249 set_game_handle_show (set_game_t        *game,
 250                       const char        *peer)
 251 {
 252     LmMessage *reply;
 253     LmMessageNode *html, *body, *span;
 254     gboolean result;
 255     GError *error = NULL;
 256     board_t *board = &game->board;
 257     char board_str[BOARD_MAX_SLOTS * (NUM_ATTRIBUTES + 1)];
 258     char *s;
 259     int slot, pos, attr;
 260
 261     reply = lm_message_new (peer, LM_MESSAGE_TYPE_MESSAGE);
 262     html = lm_message_node_add_child (reply->node, "html", "");
 263     lm_message_node_set_attribute (html,
 264                                    "xmlns",
 265                                    "http://jabber.org/protocol/xhtml-im");
 266     body = lm_message_node_add_child (html, "body", "");
 267     lm_message_node_set_attribute (body,
 268                                    "xmlns",
 269                                    "http://www.w3.org/1999/xhtml");
 270
 271     s = board_str;
 272     for (slot = 0; slot < board->num_slots; slot++) {
 273         if (slot % 4 == 0)
 274             lm_message_node_add_child (body, "br", "");
 275         if (board->slots[slot].has_card) {
 276             char card_str[5];
 277             char *style;
 278             card_t card = board->slots[slot].card;
 279             for (pos = 0; pos < 3; pos++) {
 280                 if (pos <= card.attributes[ATTRIBUTE_INDEX_NUMBER]) {
 281                     switch (card.attributes[ATTRIBUTE_INDEX_SYMBOL]) {
 282                     case SYMBOL_OVAL:
 283                         card_str[pos] = 'O';
 284                         break;
 285                     case SYMBOL_SQUIGGLE:
 286                         card_str[pos] = 'S';
 287                         break;
 288                     case SYMBOL_DIAMOND:
 289                     default:
 290                         card_str[pos] = 'X';
 291                         break;
 292                     }
 293                 } else {
 294                     card_str[pos] = ' ';
 295                 }
 296             }
 297             card_str[3] = ' ';
 298             card_str[4] = '\0';
 299             span = lm_message_node_add_child (body, "span",
 300                                               card_str);
 301             style = g_strdup_printf ("font-family: Monospace; color: %s;%s%s",
 302                                      attribute_values[ATTRIBUTE_INDEX_COLOR][
 303                                          card.attributes[ATTRIBUTE_INDEX_COLOR]],
 304                                      card.attributes[ATTRIBUTE_INDEX_SHADING]
 305                                      == SHADING_SOLID ? "font-weight: bold;" : "",
 306                                      card.attributes[ATTRIBUTE_INDEX_SHADING]
 307                                      == SHADING_STRIPED ? "text-decoration: underline;" : "");
 308             lm_message_node_set_attribute (span, "style", style);
 309             free (style);
 310             for (attr = 0; attr < NUM_ATTRIBUTES; attr++)
 311                 *s++ = '0' + board->slots[slot].card.attributes[attr];
 312             *s++ = ' ';
 313         } else {
 314             span = lm_message_node_add_child (body, "span", "    ");
 315             lm_message_node_set_attribute (span, "style",
 316                                            "font-family: Monospace;");
 317             *s++ = '-';
 318             *s++ = '-';
 319             *s++ = '-';
 320             *s++ = ' ';
 321         }
 322     }
 323     *s = '\0';
 324
 325     lm_message_node_add_child (reply->node, "body", board_str);
 326
 327     result = lm_connection_send (game->lg.connection, reply, &error);
 328     lm_message_unref (reply);
 329
 330     if (! result) {
 331         g_error ("lm_connection_send failed: %s\n",
 332                  error->message);
 333         loudgame_quit (&game->lg, 1);
 334     }
 335 }
 336
 337 static void
 338 set_game_handle_hint (set_game_t *game,
 339                       const char *peer)
 340 {
 341     loudgame_sendf (&game->lg, peer, "Sets possible: %d",
 342                     game->board.sets_possible);
 343 }
 344
 345 static void
 346 set_game_handle_shuffle (set_game_t *game,
 347                          const char *peer)
 348 {
 349     if (game->board.sets_possible) {
 350         loudgame_sendf (&game->lg, peer,
 351                         "There are %d sets, refusing to shuffle.",
 352                         game->board.sets_possible);
 353         return;
 354     }
 355
 356     if (game->deck.num_cards == 0) {
 357         loudgame_sendf (&game->lg, peer,
 358                         "Deck exhausted, starting a new game.");
 359         set_game_new_game (game);
 360     } else {
 361         set_game_shuffle (game);
 362     }
 363 }
 364
 365 static void
 366 set_game_handle_set (set_game_t *game,
 367                      const char *peer,
 368                      const char *message)
 369 {
 370     const char *s;
 371     char *end = NULL;
 372     int i;
 373     int slots[3];
 374     card_t cards[3];
 375
 376     s = message;
 377     i = 0;
 378     while (*s && i < 3) {
 379         slots[i++] = strtoul (s, &end, 10);
 380         if (end == s) {
 381             loudgame_sendf (&game->lg, peer,
 382                             "Error: Not an integer: %s", s);
 383             return;
 384         }
 385         s = end;
 386     }
 387
 388     while (end && *end && isspace (*end))
 389         end++;
 390
 391     if (i != 3 || *end != '\0') {
 392         loudgame_sendf (&game->lg, peer,
 393                         "Error: The 'set' command requires exactly 3 integers");
 394         return;
 395     }
 396
 397     for (i = 0; i < 3; i++) {
 398         if (slots[i] < 0 || slots[i] > BOARD_MAX_SLOTS) {
 399             loudgame_sendf (&game->lg, peer,
 400                             "Error: Value %d is out of range (0-%d)",
 401                             slots[i], BOARD_MAX_SLOTS);
 402             return;
 403         }
 404     }
 405
 406     if (slots[0] == slots[1] ||
 407         slots[0] == slots[2] ||
 408         slots[1] == slots[2])
 409     {
 410             loudgame_sendf (&game->lg, peer,
 411                             "Error: All 3 values must be unique");
 412             return;
 413     }
 414
 415     for (i=0; i < 3; i++) {
 416         if (game->board.slots[slots[i]].has_card) {
 417             cards[i] = game->board.slots[slots[i]].card;
 418         } else {
 419             loudgame_sendf (&game->lg, peer,
 420                             "Error: There's no card at position %d", i);
 421             return;
 422         }
 423     }
 424
 425     if (! is_set (cards, 3)) {
 426         loudgame_sendf (&game->lg, peer,
 427                         "Sorry, that's not a set");
 428         return;
 429     }
 430
 431     loudgame_sendf (&game->lg, peer,
 432                     "Yes, that's a set!");
 433
 434     for (i = 0; i < 3; i++)
 435         game->board.slots[slots[i]].has_card = 0;
 436
 437     board_count_sets_possible (&game->board);
 438
 439     deal (&game->deck, &game->board);
 440 }
 441
 442 static void
 443 set_game_handle_help (set_game_t *game,
 444                       const char *peer)
 445 {
 446     loudgame_sendf (&game->lg, peer,
 447                     "I'm a bot that allows you to play the game of SET.\n"
 448                     "Here are some commands I understand:\n"
 449                     "\tshow     \tShow the current cards on the board\n"
 450                     "\thint     \tIndicate how many sets are currently possible\n"
 451                     "\tshuffle  \tReturn the cards to the deck, shuffle and deal\n"
 452                     "\t         \t(this is only allowed if no sets are possible)\n"
 453                     "\tset X Y Z\tClaim three cards as a set. The cards are numbered\n"
 454                     "\t         \tleft-to-right, and top-to-bottom from 0 to 11.\n"
 455                     "\n"
 456                     "For more information about SET, or to purchase your own deck, visit\n"
 457                     "http://setgame.com . Please note that this server is unaffiliated\n"
 458                     "with Set Enterprises, Inc., who publish the SET card game.");
 459 }
 460
 461 static void
 462 set_game_handle_message (loudgame_t *lg,
 463                          const char *peer,
 464                          const char *message)
 465 {
 466     set_game_t *game = (set_game_t*) lg;
 467
 468     if (strcmp (message, "show") == 0)
 469         set_game_handle_show (game, peer);
 470     else if (strcmp (message, "help") == 0)
 471         set_game_handle_help (game, peer);
 472     else if (strcmp (message, "hint") == 0)
 473         set_game_handle_hint (game, peer);
 474     else if (strcmp (message, "shuffle") == 0)
 475         set_game_handle_shuffle (game, peer);
 476     else if (strncmp (message, "set", 3) == 0)
 477         set_game_handle_set (game, peer, message + 3);
 478     else
 479         loudgame_sendf (lg, peer, "Unknown command: '%s'. Use 'help' to get a list of valid commands.", message);
 480 }
 481
 482 /* Begin a new game */
 483 static void
 484 set_game_new_game (set_game_t *game)
 485 {
 486     deck_init (&game->deck);
 487     board_init (&game->board);
 488     deal (&game->deck, &game->board);
 489 }
 490
 491 static int
 492 set_game_init (set_game_t *game, int argc, char *argv[])
 493 {
 494     int err;
 495
 496     err = loudgame_init (&game->lg, argc, argv);
 497     if (err)
 498         return err;
 499
 500     set_game_new_game (game);
 501
 502     return 0;
 503 }
 504
 505 /* Return the dealt cards to the deck, reshuffle, and deal again. */
 506 static int
 507 set_game_shuffle (set_game_t *game)
 508 {
 509     board_t *board = &game->board;
 510     deck_t *deck = &game->deck;
 511     int i;
 512
 513     for (i=0; i < board->num_slots; i++) {
 514         if (board->slots[i].has_card) {
 515             deck->cards[++deck->num_cards - 1] = board->slots[i].card;
 516             board->slots[i].has_card = 0;
 517             board->slots[i].selected = 0;
 518         }
 519     }
 520
 521     deck_shuffle (deck);
 522     deal (deck, board);
 523
 524     return 1;
 525 }
 526
 527 int
 528 main (int argc, char *argv[])
 529 {
 530     set_game_t game;
 531     int err;
 532
 533     srand (time(0));
 534
 535     err = set_game_init (&game, argc, argv);
 536     if (err)
 537         return err;
 538
 539     game.lg.handle_message = set_game_handle_message;
 540
 541     err = loudgame_run (&game.lg);
 542     if (err)
 543         return err;
 544
 545     return 0;
 546 }