Document the new say and whisper commands
[loudgame] / lg-loa.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 <stdint.h>
25
26 #include <string.h>
27 #include <ctype.h>
28 #include <assert.h>
29
30 typedef int loa_bool_t;
31
32 #ifndef FALSE
33 #define FALSE 0
34 #endif
35 #ifndef TRUE
36 #define TRUE  1
37 #endif
38
39 typedef enum {
40     PLAYER_BLACK,
41     PLAYER_WHITE
42 } player_t;
43
44 typedef enum {
45     CELL_BLACK = PLAYER_BLACK,
46     CELL_WHITE = PLAYER_WHITE,
47     CELL_EMPTY
48 } cell_t;
49
50 /* The implementation of board_group_size depends on the square of
51  * BOARD_SIZE being less than or equal to 64. */
52 #define BOARD_SIZE 8
53 #define DIAG_ARRAY_SIZE (2 * BOARD_SIZE - 1)
54
55 typedef struct {
56     cell_t cells[BOARD_SIZE][BOARD_SIZE];
57
58     /* Number of black and white pieces */
59     int num_pieces[2];
60
61     /* Number of pieces (of either color) in each row, column, and
62      * diagonal. */
63     int row_pieces[BOARD_SIZE];
64     int col_pieces[BOARD_SIZE];
65     int diag_grave_pieces[DIAG_ARRAY_SIZE];
66     int diag_acute_pieces[DIAG_ARRAY_SIZE];
67 } board_t;
68
69 typedef struct _loa_game {
70     loudgame_t lg;
71     board_t board;
72     player_t current;
73 } loa_game_t;
74
75 static int
76 board_group_size_recursive (board_t *board, int x, int y,
77                             cell_t cell,
78                             uint64_t *visited)
79 {
80     uint64_t bit;
81
82     if (x < 0 || y < 0)
83         return 0;
84
85     if (x >= BOARD_SIZE || y >= BOARD_SIZE)
86         return 0;
87
88     bit = 1ll << (x * BOARD_SIZE + y);
89     if (*visited & bit)
90         return 0;
91
92     *visited |= bit;
93
94     if (board->cells[x][y] != cell)
95         return 0;
96
97     return 1 +
98         board_group_size_recursive (board, x-1, y-1, cell, visited) +
99         board_group_size_recursive (board, x-1, y  , cell, visited) +
100         board_group_size_recursive (board, x-1, y+1, cell, visited) +
101         board_group_size_recursive (board, x  , y-1, cell, visited) +
102         board_group_size_recursive (board, x  , y  , cell, visited) +
103         board_group_size_recursive (board, x  , y+1, cell, visited) +
104         board_group_size_recursive (board, x+1, y-1, cell, visited) +
105         board_group_size_recursive (board, x+1, y  , cell, visited) +
106         board_group_size_recursive (board, x+1, y+1, cell, visited);
107 }
108
109 static int
110 board_group_size (board_t *board, int x, int y)
111 {
112     uint64_t visited = 0ll;
113     cell_t cell = board->cells[x][y];
114
115     return board_group_size_recursive (board, x, y, cell, &visited);
116 }
117
118 static int
119 board_is_won (board_t *board, int x, int y)
120 {
121     cell_t cell = board->cells[x][y];
122
123     if (cell == CELL_EMPTY)
124         return 0;
125
126     if (board_group_size (board, x, y) == board->num_pieces[cell])
127         return 1;
128
129     return 0;
130 }
131
132 /* Given an (x,y) position on the board, return the index of the array
133  * used to count pieces in diagonal rows running from upper-left to
134  * lower-right, (like a grave accent: à or like a backslash: \).
135  *
136  * This is the array to look into when a move occurs with dx and dy of
137  * the same sign. */
138 static int
139 _grave_index (int x, int y)
140 {
141     return x - y + BOARD_SIZE - 1;
142 }
143
144 /* Given an (x,y) position on the board, return the index of the array
145  * used to count pieces in diagonal rows running from lower-left to
146  * upper-right, (like an acute accent: á or like a forward slash: /).
147  *
148  * This is the array to look into when a move occurs with dx and dy of
149  * opposite sign, (one positive, one negative). */
150 static int
151 _acute_index (int x, int y)
152 {
153     return x + y;
154 }
155
156 static loa_bool_t
157 board_move_legal (board_t *board, int x1, int y1, int x2, int y2, char **error)
158 {
159     int x, y;
160     int dx, dy;
161     int step_x, step_y;
162
163     if (board->cells[x1][y1] == CELL_EMPTY) {
164         *error = "There is no piece there to move";
165         return FALSE;
166     }
167
168     if (board->cells[x2][y2] == board->cells[x1][y1]) {
169         *error = "You cannot capture your own piece";
170         return FALSE;
171     }
172
173     dx = x2 - x1;
174     dy = y2 - y1;
175
176     /* Here's the meat of Lines of Action legaility: Does the distance
177      * moved exactly match the number of pieces (of either color) in
178      * the row, column, or diagonal of the movement. */
179     if (dx == 0) { 
180         /* Column */
181         if (abs (dy) != board->col_pieces[x1]) {
182             *error = "The move distance does not match the number of pieces in that column";
183             return FALSE;
184         }
185     } else if (dy == 0) {
186         /* Row */
187         if (abs (dx) != board->row_pieces[y1]) {
188             *error = "The move distance does not match the number of pieces in that row";
189             return FALSE;
190         }
191     } else {
192         if (abs (dx) != abs (dy)) {
193             *error = "That move is not in a row, column, or diagonal";
194             return FALSE;
195         }
196         /* Diagonal */
197         if ((dx > 0) == (dy > 0)) {
198             if (abs (dx) != board->diag_grave_pieces[_grave_index (x1, y1)]) {
199                 *error = "The move distance does not match the number of pieces in that diagonal";
200                 return FALSE;
201             }
202         } else {
203             if (abs (dx) != board->diag_acute_pieces[_acute_index (x1, y1)]) {
204                 *error = "The move distance does not match the number of pieces in that diagonal";
205                 return FALSE;
206             }
207         }
208     }
209
210     /* Finally, we have to ensure that no opponent pieces are being
211      * jumped. */
212     step_x = dx ? ((dx < 0) ? -1 : +1) : 0;
213     step_y = dy ? ((dy < 0) ? -1 : +1) : 0;
214     for (x = x1 + step_x, y = y1 + step_y;
215          x != x2 || y != y2;
216          x += step_x, y += step_y)
217     {
218         if (board->cells[x][y] != CELL_EMPTY &&
219             board->cells[x][y] != board->cells[x1][y1])
220         {
221             *error = "You cannot jump an opponent's piece";
222             return FALSE;
223         }
224     }
225
226     return TRUE;
227 }
228
229 static void
230 board_add_piece (board_t *board, int x, int y, cell_t cell)
231 {
232     assert (cell == CELL_BLACK || cell == CELL_WHITE);
233     assert (board->cells[x][y] == CELL_EMPTY);
234
235     board->col_pieces[x]++;
236     board->row_pieces[y]++;
237     board->diag_grave_pieces[_grave_index (x, y)]++;
238     board->diag_acute_pieces[_acute_index (x, y)]++;
239
240     board->num_pieces[cell]++;
241
242     board->cells[x][y] = cell;
243 }
244
245 static cell_t
246 board_remove_piece (board_t *board, int x, int y)
247 {
248     cell_t cell;
249
250     cell = board->cells[x][y];
251
252     if (cell == CELL_EMPTY)
253         return CELL_EMPTY;
254
255     board->col_pieces[x]--;
256     board->row_pieces[y]--;
257     board->diag_grave_pieces[_grave_index (x, y)]--;
258     board->diag_acute_pieces[_acute_index (x, y)]--;
259
260     board->num_pieces[cell]--;
261
262     board->cells[x][y] = CELL_EMPTY;
263
264     return cell;
265 }
266
267 static void
268 board_init (board_t *board)
269 {
270     int i, x, y;
271
272     for (x = 0; x < BOARD_SIZE; x++)
273         for (y = 0; y < BOARD_SIZE; y++)
274             board->cells[x][y] = CELL_EMPTY;
275
276     board->num_pieces[CELL_BLACK] = 0;
277     board->num_pieces[CELL_WHITE] = 0;
278
279     for (i = 0; i < BOARD_SIZE; i++) {
280         board->row_pieces[i] = 0;
281         board->col_pieces[i] = 0;
282     }
283
284     for (i = 0; i < DIAG_ARRAY_SIZE; i++) {
285         board->diag_grave_pieces[i] = 0;
286         board->diag_acute_pieces[i] = 0;
287     }
288
289     for (i = 1; i < BOARD_SIZE - 1; i++) {
290         board_add_piece (board, i, 0, CELL_BLACK);
291         board_add_piece (board, i, BOARD_SIZE - 1, CELL_BLACK);
292         board_add_piece (board, 0, i, CELL_WHITE);
293         board_add_piece (board, BOARD_SIZE - 1, i, CELL_WHITE);
294     }
295 }
296
297 /* A few different ideas for displaying boards:
298  *
299  * 8│ │●│●│●│●│●│●│ |       8| |*|*|*|*|*|*| |
300  * 7│○│ │ │ │ │ │ │○|       7|o| | | | | | |o|
301  * 6│○│ │ │ │ │ │ │○|       6|o| | | | | | |o|
302  * 5│○│ │ │ │ │ │ │○|       5|o| | | | | | |o|
303  * 4│○│ │ │ │ │ │ │○|       4|o| | | | | | |o|
304  * 3│○│ │ │ │ │ │ │○|       3|o| | | | | | |o|
305  * 2│○│ │ │ │ │ │ │○|       2|o| | | | | | |o|
306  * 1│ │●│●│●│●│●│●│ |       1| |*|*|*|*|*|*| |
307  *   A B C D E F G H      A B C D E F G H
308  *
309  *  ┌───┬───┬───┬───┬───┬───┬───┬───┐   ------------------------------- 
310  * 8│   │ ● │ ● │ ● │ ● │ ● │ ● │   │     8|   | * | * | * | * | * | * |   |
311  *  ├───┼───┼───┼───┼───┼───┼───┼───┤  |---+---+---+---+---+---+---+---|
312  * 7│ ○ │   │   │   │   │   │   │ ○ │     7| o |   |   |   |   |   |   | o |
313  *  ├───┼───┼───┼───┼───┼───┼───┼───┤  |---+---+---+---+---+---+---+---|
314  * 6│ ○ │   │   │   │   │   │   │ ○ │     6| o |   |   |   |   |   |   | o |
315  *  ├───┼───┼───┼───┼───┼───┼───┼───┤  |---+---+---+---+---+---+---+---|
316  * 5│ ○ │   │   │   │   │   │   │ ○ │     5| o |   |   |   |   |   |   | o |
317  *  ├───┼───┼───┼───┼───┼───┼───┼───┤  |---+---+---+---+---+---+---+---|
318  * 4│ ○ │   │   │   │   │   │   │ ○ │     4| o |   |   |   |   |   |   | o |
319  *  ├───┼───┼───┼───┼───┼───┼───┼───┤  |---+---+---+---+---+---+---+---|
320  * 3│ ○ │   │   │   │   │   │   │ ○ │     3| o |   |   |   |   |   |   | o |
321  *  ├───┼───┼───┼───┼───┼───┼───┼───┤  |---+---+---+---+---+---+---+---|
322  * 2│ ○ │   │   │   │   │   │   │ ○ │     2| o |   |   |   |   |   |   | o |
323  *  ├───┼───┼───┼───┼───┼───┼───┼───┤  |---+---+---+---+---+---+---+---|
324  * 1│   │ ● │ ● │ ● │ ● │ ● │ ● │   │     1|   | * | * | * | * | * | * |   |
325  *  └───┴───┴───┴───┴───┴───┴───┴───┘   ------------------------------- 
326  *    A   B   C   D   E   F   G   H        A   B   C   D   E   F   G   H
327  */
328 static char *
329 board_to_string (board_t *board)
330 {
331     int x, y;
332     /* In order of BLACK, WHITE, EMPTY */
333     const char* cell_strings[] = {"●","○"," "};
334     const char   board_header[] = "┌───┬───┬───┬───┬───┬───┬───┬───┐";
335     const char     row_header[] = "│ ";
336     const char cell_separator[] =    " │ ";
337     const char     row_footer[] =                                " │";
338     const char  row_separator[] = "├───┼───┼───┼───┼───┼───┼───┼───┤";
339     const char   board_footer[] = "└───┴───┴───┴───┴───┴───┴───┴───┘";
340     char *board_string = g_strdup ("");
341
342 #define APPEND(str) do {                                        \
343     char *_new = g_strconcat (board_string, (str), NULL);       \
344     free (board_string);                                        \
345     board_string = _new;                                        \
346 } while (0)
347
348 #define APPENDF(format, ...) do {                               \
349     char *str = g_strdup_printf (format, ## __VA_ARGS__);       \
350     APPEND (str);                                               \
351     free (str);                                                 \
352 } while (0)
353
354     APPENDF (" %s\n", board_header);
355     for (y = 0; y < BOARD_SIZE; y++) {
356         APPENDF ("%d%s", BOARD_SIZE - y, row_header);
357         for (x = 0; x < BOARD_SIZE; x++) {
358             APPENDF ("%s", cell_strings[board->cells[x][y]]);
359             if (x != BOARD_SIZE - 1)
360                 APPENDF ("%s", cell_separator);
361         }
362         APPENDF ("%s\n", row_footer);
363         if (y != BOARD_SIZE -1)
364             APPENDF (" %s\n", row_separator);
365     }
366     APPENDF (" %s\n", board_footer);
367
368     APPENDF ("   ");
369     for (x = 0; x < BOARD_SIZE; x++) {
370         APPENDF ("%c", 'A' + x);
371         if (x != BOARD_SIZE - 1)
372             APPENDF ("   ");
373     }
374     APPENDF ("\n");
375
376     return board_string;
377 }
378
379 static void
380 loa_game_new_game (loa_game_t *game)
381 {
382     board_init (&game->board);
383     game->current = PLAYER_BLACK;
384 }
385
386 static void
387 loa_game_next_player (loa_game_t *game)
388 {
389     if (game->current == PLAYER_BLACK)
390         game->current = PLAYER_WHITE;
391     else
392         game->current = PLAYER_BLACK;
393 }
394
395 static loa_bool_t
396 loa_game_move (loa_game_t *game, const char * peer,
397                int x1, int y1, int x2, int y2)
398 {
399     board_t *board = &game->board;
400     cell_t cell;
401     char *error;
402
403     if (x1 < 0 || y1 < 0 || x1 >= BOARD_SIZE || y1 >= BOARD_SIZE) {
404         loudgame_sendf (&game->lg, peer, "Invalid coordinates (not on board).");
405         return FALSE;
406     }
407
408     if (board->cells[x1][y1] != game->current) {
409         loudgame_sendf (&game->lg, peer, "Cell at (%d,%d) does not belong to current player.",
410                         x1, y1);
411         return FALSE;
412     }
413
414     if (! board_move_legal (&game->board, x1, y1, x2, y2, &error)) {
415         loudgame_sendf (&game->lg, peer, "Illegal move: %s.");
416         return FALSE;
417     }
418
419     cell = board_remove_piece (board, x1, y1);
420     board_remove_piece (board, x2, y2);
421     board_add_piece (board, x2, y2, cell);
422
423     loa_game_next_player (game);
424
425     return TRUE;
426 }
427
428 static void
429 loa_game_handle_show (loa_game_t *game,
430                       const char *peer)
431 {
432     LmMessage *reply;
433     LmMessageNode *html, *body, *span;
434     gboolean result;
435     GError *error = NULL;
436     char *board_string;
437     char *line, *newline;
438
439     reply = lm_message_new (peer, LM_MESSAGE_TYPE_MESSAGE);
440     html = lm_message_node_add_child (reply->node, "html", "");
441     lm_message_node_set_attribute (html,
442                                    "xmlns",
443                                    "http://jabber.org/protocol/xhtml-im");
444     body = lm_message_node_add_child (html, "body", "");
445     lm_message_node_set_attribute (body,
446                                    "xmlns",
447                                    "http://www.w3.org/1999/xhtml");
448
449     if (game->current == PLAYER_BLACK)
450         lm_message_node_add_child (body, "span", "Black to move:");
451     else
452         lm_message_node_add_child (body, "span", "White to move:");
453
454     board_string = board_to_string (&game->board);
455
456     line = board_string;
457     while (1) {
458         newline = strchr (line, '\n');
459         if (newline)
460             *newline = '\0';
461         lm_message_node_add_child (body, "br", "");
462         span = lm_message_node_add_child (body, "span", line);
463         lm_message_node_set_attribute (span, "style",
464                                        "font-family: Monospace;");
465         if (! newline)
466             break;
467         line = newline + 1;
468     }
469
470     free (board_string);
471
472     result = lm_connection_send (game->lg.connection, reply, &error);
473     lm_message_unref (reply);
474
475     if (! result) {
476         g_error ("lm_connection_send failed: %s\n",
477                  error->message);
478         loudgame_quit (&game->lg, 1);
479     }
480 }
481
482 static void
483 loa_game_handle_move (loa_game_t *game,
484                       const char *peer,
485                       const char *move)
486 {
487     char xc1, xc2;
488     int x1, y1, x2, y2;
489     int matched;
490
491     matched = sscanf (move, " %c %d %c %d ", &xc1, &y1, &xc2, &y2);
492     if (matched != 4) {
493         loudgame_sendf (&game->lg, peer,
494                         "Error: The 'move' command requires a move of the form 'b1d3'");
495         return;
496     }
497
498     x1 = tolower (xc1) - 'a';
499     x2 = tolower (xc2) - 'a';
500     /* We use an upper-left origin internally. */
501     y1 = BOARD_SIZE - y1;
502     y2 = BOARD_SIZE - y2;
503     if (! loa_game_move (game, peer, x1, y1, x2, y2))
504         return;
505
506     loudgame_broadcastf (&game->lg, "%c%d%c%d",
507                          'a' + x1, BOARD_SIZE - y1,
508                          'a' + x2, BOARD_SIZE - y2);
509
510     if (board_is_won (&game->board, x2, y2))
511         loudgame_broadcastf (&game->lg, "%s wins", peer);
512 }
513
514 static void
515 loa_game_handle_pass (loa_game_t *game, const char *peer)
516 {
517     loudgame_broadcastf (&game->lg, "%s passes", peer);
518
519     loa_game_next_player (game);
520 }
521
522 static void
523 loa_game_handle_help (loa_game_t *game, const char *peer)
524 {
525     loudgame_sendf (&game->lg, peer,
526                     "I'm a bot that allows you to play the game Lines of Action.\n"
527                     "Here are some generic commands I understand:\n"
528                     LOUDGAME_HELP
529                     "\n"
530                     "And some game-specific commands:\n"
531                     "\tshow     \t\tShow the current board\n"
532                     "\tmove aNbN\tMove a piece, (eg. 'move b1d3')\n"
533                     "\tpass     \t\tSkip a turn (only legal if no moves are possible)\n"
534                     "\tnew      \t\tBegin a new game\n"
535                     "\thelp     \t\tThis help message\n"
536                     "\trules    \t\tA description of the Lines of Action rules\n"
537                     "\n"
538                     "Lines of Action was invented by Claude Soucie and first made popular\n"
539                     "when its rules were published by Sid Sackson in \"A Gamut of Games\" (1969).\n"
540                     "\n"
541                     "If you are new to Lines of Action, type 'rules' now to learn the rules.\n");
542 }
543
544 static void
545 loa_game_handle_rules (loa_game_t *game, const char *peer)
546 {
547     loudgame_sendf (&game->lg, peer,
548                     "Lines of Action can be played with a standard (English) checkers set,\n"
549                     "that is an 8x8 board and 12 markers each of contrasting colors ('black' and\n"
550                     "'white'). The initial placement has 6 each of the black pieces on the top\n"
551                     "and bottom rows, and 6 each of the white pieces on the left and right columns\n"
552                     "leaving the four corner spaces empty. Play begins with the black player and\n"
553                     "then alternates.\n"
554                     "\n"
555                     "On each move a piece is moved in a straight line in any of eight directions,\n"
556                     "(similar to a queen's move in chess), but must be moved exactly the same\n"
557                     "number of spaces as there are pieces (of either color) in the row, column,\n"
558                     "or diagonal of the move. A piece may jump over pieces of its own color, but\n"
559                     "may not jump a piece of the opposite color. The final square of the move can\n"
560                     "be either empty or can contain a piece of the opposing color, in which case\n"
561                     "that piece is removed from the game.\n"
562                     "\n"
563                     "If a player has no possible move, then that player must pass, (but if the\n"
564                     "player has a possible move, then the player cannot pass).\n"
565                     "\n"
566                     "The goal of the game is to connect all of your remaining pieces into\n"
567                     "a single, connected group. Pieces that are diagonally adjacent are\n"
568                     "considered connected.\n"
569                     "\n"
570                     "If a move simultaneously creates a winning condition for both players, this\n"
571                     "is considered a win for the player making the move.\n"
572                     "\n"
573                     "Notes on this implementation:\n"
574                     "\n"
575                     "This implementation enforces the move rules described above, but will\n"
576                     "allow any person to make moves, (that is, you can control both\n"
577                     "colors). Think of it as being somewhat like a physical board where\n"
578                     "any person could move the pieces at any time, but generally two people\n"
579                     "will take turns and others will politely watch.\n"
580                     "\n"
581                     "Also, the game won't currently show you the board again after a\n"
582                     "player makes a move, so you'll need to keep typing 'show' to see\n"
583                     "updates. Yes, this is a bug, and yes it will be fixed soon.\n"
584                     "\n"
585                     "Lines of Action was invented by Claude Soucie and first made popular\n"
586                     "when its rules were published by Sid Sackson in \"A Gamut of Games\" (1969).\n");
587 }
588
589 static void
590 loa_game_handle_new (loa_game_t *game, const char *peer)
591 {
592     loudgame_broadcastf (&game->lg, "%s has started a new game", peer);
593     loa_game_new_game (game);
594 }
595
596 static void
597 loa_game_handle_message (loudgame_t *lg,
598                          const char *peer,
599                          const char *message)
600 {
601     loa_game_t *game = (loa_game_t *) lg;
602
603     if (strcmp (message, "show") == 0)
604         loa_game_handle_show (game, peer);
605     else if (strncmp (message, "move", 4) == 0)
606         loa_game_handle_move (game, peer, message + 4);
607     else if (strcmp (message, "pass") == 0)
608         loa_game_handle_pass (game, peer);
609     else if (strcmp (message, "new") == 0)
610         loa_game_handle_new (game, peer);
611     else if (strcmp (message, "help") == 0)
612         loa_game_handle_help (game, peer);
613     else if (strcmp (message, "rules") == 0)
614         loa_game_handle_rules (game, peer);
615     else
616         loudgame_sendf (lg, peer, "Unknown command: '%s'. Use 'help' to get a list of valid commands.", message);
617 }
618
619 static int
620 loa_game_init (loa_game_t *game, int argc, char *argv[])
621 {
622     int err;
623
624     err = loudgame_init (&game->lg, argc, argv);
625     if (err)
626         return err;
627
628     loa_game_new_game (game);
629
630     return 0;
631 }
632
633 int
634 main (int argc, char **argv)
635 {
636     loa_game_t game;
637     int err;
638
639     err = loa_game_init (&game, argc, argv);
640     if (err)
641         return err;
642
643     game.lg.handle_message = loa_game_handle_message;
644
645     err = loudgame_run (&game.lg);
646     if (err)
647         return err;
648
649     return 0;
650 }