More loa-prefix additions.

diff --git a/lg-loa.c b/lg-loa.c
index 0d582c9def03412357aaa4ede5c58476ece221ed..d2660d2a4675f8b36a674bdd247c9ee5fe6a14c9 100644 (file)
--- a/lg-loa.c
+++ b/lg-loa.c
@@ -37,35 +37,35 @@ typedef int loa_bool_t;
 #endif
 
 typedef enum {
-    PLAYER_BLACK,
-    PLAYER_WHITE
-} player_t;
+    LOA_PLAYER_BLACK,
+    LOA_PLAYER_WHITE
+} loa_player_t;
 
 typedef enum {
-    CELL_BLACK = PLAYER_BLACK,
-    CELL_WHITE = PLAYER_WHITE,
-    CELL_EMPTY
-} cell_t;
+    LOA_CELL_BLACK = LOA_PLAYER_BLACK,
+    LOA_CELL_WHITE = LOA_PLAYER_WHITE,
+    LOA_CELL_EMPTY
+} loa_cell_t;
 
 /* The implementation of board_group_size depends on the square of
  * BOARD_SIZE being less than or equal to 64. */
-#define BOARD_SIZE 8
-#define DIAG_ARRAY_SIZE (2 * BOARD_SIZE - 1)
+#define LOA_BOARD_SIZE 8
+#define LOA_DIAG_ARRAY_SIZE (2 * LOA_BOARD_SIZE - 1)
 
 typedef struct {
-    cell_t cells[BOARD_SIZE][BOARD_SIZE];
+    loa_cell_t cells[LOA_BOARD_SIZE][LOA_BOARD_SIZE];
 
     /* Number of black and white pieces */
     int num_pieces[2];
 
     /* Number of pieces (of either color) in each row, column, and
      * diagonal. */
-    int row_pieces[BOARD_SIZE];
-    int col_pieces[BOARD_SIZE];
-    int diag_grave_pieces[DIAG_ARRAY_SIZE];
-    int diag_acute_pieces[DIAG_ARRAY_SIZE];
+    int row_pieces[LOA_BOARD_SIZE];
+    int col_pieces[LOA_BOARD_SIZE];
+    int diag_grave_pieces[LOA_DIAG_ARRAY_SIZE];
+    int diag_acute_pieces[LOA_DIAG_ARRAY_SIZE];
 
-    player_t player;
+    loa_player_t player;
 } loa_board_t;
 
 typedef struct _loa_game {
@@ -76,15 +76,15 @@ typedef struct _loa_game {
 static void
 loa_board_next_player (loa_board_t *board)
 {
-    if (board->player == PLAYER_BLACK)
-       board->player = PLAYER_WHITE;
+    if (board->player == LOA_PLAYER_BLACK)
+       board->player = LOA_PLAYER_WHITE;
     else
-       board->player = PLAYER_BLACK;
+       board->player = LOA_PLAYER_BLACK;
 }
 
 static int
 loa_board_group_size_recursive (loa_board_t *board, int x, int y,
-                               cell_t cell,
+                               loa_cell_t cell,
                                uint64_t *visited)
 {
     uint64_t bit;
@@ -92,10 +92,10 @@ loa_board_group_size_recursive (loa_board_t *board, int x, int y,
     if (x < 0 || y < 0)
        return 0;
 
-    if (x >= BOARD_SIZE || y >= BOARD_SIZE)
+    if (x >= LOA_BOARD_SIZE || y >= LOA_BOARD_SIZE)
        return 0;
 
-    bit = 1ll << (x * BOARD_SIZE + y);
+    bit = 1ll << (x * LOA_BOARD_SIZE + y);
     if (*visited & bit)
        return 0;
 
@@ -120,7 +120,7 @@ static int
 loa_board_group_size (loa_board_t *board, int x, int y)
 {
     uint64_t visited = 0ll;
-    cell_t cell = board->cells[x][y];
+    loa_cell_t cell = board->cells[x][y];
 
     return loa_board_group_size_recursive (board, x, y, cell, &visited);
 }
@@ -128,9 +128,9 @@ loa_board_group_size (loa_board_t *board, int x, int y)
 static int
 loa_board_is_won (loa_board_t *board, int x, int y)
 {
-    cell_t cell = board->cells[x][y];
+    loa_cell_t cell = board->cells[x][y];
 
-    if (cell == CELL_EMPTY)
+    if (cell == LOA_CELL_EMPTY)
        return 0;
 
     if (loa_board_group_size (board, x, y) == board->num_pieces[cell])
@@ -148,7 +148,7 @@ loa_board_is_won (loa_board_t *board, int x, int y)
 static int
 _grave_index (int x, int y)
 {
-    return x - y + BOARD_SIZE - 1;
+    return x - y + LOA_BOARD_SIZE - 1;
 }
 
 /* Given an (x,y) position on the board, return the index of the array
@@ -173,7 +173,7 @@ loa_board_move_legal (loa_board_t *board,
     int dx, dy;
     int step_x, step_y;
 
-    if (board->cells[x1][y1] == CELL_EMPTY) {
+    if (board->cells[x1][y1] == LOA_CELL_EMPTY) {
        *error = "There is no piece there to move";
        return FALSE;
     }
@@ -228,7 +228,7 @@ loa_board_move_legal (loa_board_t *board,
         x != x2 || y != y2;
         x += step_x, y += step_y)
     {
-       if (board->cells[x][y] != CELL_EMPTY &&
+       if (board->cells[x][y] != LOA_CELL_EMPTY &&
            board->cells[x][y] != board->cells[x1][y1])
        {
            *error = "You cannot jump an opponent's piece";
@@ -240,10 +240,10 @@ loa_board_move_legal (loa_board_t *board,
 }
 
 static void
-loa_board_add_piece (loa_board_t *board, int x, int y, cell_t cell)
+loa_board_add_piece (loa_board_t *board, int x, int y, loa_cell_t cell)
 {
-    assert (cell == CELL_BLACK || cell == CELL_WHITE);
-    assert (board->cells[x][y] == CELL_EMPTY);
+    assert (cell == LOA_CELL_BLACK || cell == LOA_CELL_WHITE);
+    assert (board->cells[x][y] == LOA_CELL_EMPTY);
 
     board->col_pieces[x]++;
     board->row_pieces[y]++;
@@ -255,15 +255,15 @@ loa_board_add_piece (loa_board_t *board, int x, int y, cell_t cell)
     board->cells[x][y] = cell;
 }
 
-static cell_t
+static loa_cell_t
 loa_board_remove_piece (loa_board_t *board, int x, int y)
 {
-    cell_t cell;
+    loa_cell_t cell;
 
     cell = board->cells[x][y];
 
-    if (cell == CELL_EMPTY)
-       return CELL_EMPTY;
+    if (cell == LOA_CELL_EMPTY)
+       return LOA_CELL_EMPTY;
 
     board->col_pieces[x]--;
     board->row_pieces[y]--;
@@ -272,7 +272,7 @@ loa_board_remove_piece (loa_board_t *board, int x, int y)
 
     board->num_pieces[cell]--;
 
-    board->cells[x][y] = CELL_EMPTY;
+    board->cells[x][y] = LOA_CELL_EMPTY;
 
     return cell;
 }
@@ -282,31 +282,31 @@ loa_board_init (loa_board_t *board)
 {
     int i, x, y;
 
-    for (x = 0; x < BOARD_SIZE; x++)
-       for (y = 0; y < BOARD_SIZE; y++)
-           board->cells[x][y] = CELL_EMPTY;
+    for (x = 0; x < LOA_BOARD_SIZE; x++)
+       for (y = 0; y < LOA_BOARD_SIZE; y++)
+           board->cells[x][y] = LOA_CELL_EMPTY;
 
-    board->num_pieces[CELL_BLACK] = 0;
-    board->num_pieces[CELL_WHITE] = 0;
+    board->num_pieces[LOA_CELL_BLACK] = 0;
+    board->num_pieces[LOA_CELL_WHITE] = 0;
 
-    for (i = 0; i < BOARD_SIZE; i++) {
+    for (i = 0; i < LOA_BOARD_SIZE; i++) {
        board->row_pieces[i] = 0;
        board->col_pieces[i] = 0;
     }
 
-    for (i = 0; i < DIAG_ARRAY_SIZE; i++) {
+    for (i = 0; i < LOA_DIAG_ARRAY_SIZE; i++) {
        board->diag_grave_pieces[i] = 0;
        board->diag_acute_pieces[i] = 0;
     }
 
-    for (i = 1; i < BOARD_SIZE - 1; i++) {
-       loa_board_add_piece (board, i, 0, CELL_BLACK);
-       loa_board_add_piece (board, i, BOARD_SIZE - 1, CELL_BLACK);
-       loa_board_add_piece (board, 0, i, CELL_WHITE);
-       loa_board_add_piece (board, BOARD_SIZE - 1, i, CELL_WHITE);
+    for (i = 1; i < LOA_BOARD_SIZE - 1; i++) {
+       loa_board_add_piece (board, i, 0, LOA_CELL_BLACK);
+       loa_board_add_piece (board, i, LOA_BOARD_SIZE - 1, LOA_CELL_BLACK);
+       loa_board_add_piece (board, 0, i, LOA_CELL_WHITE);
+       loa_board_add_piece (board, LOA_BOARD_SIZE - 1, i, LOA_CELL_WHITE);
     }
 
-    board->player = PLAYER_BLACK;
+    board->player = LOA_PLAYER_BLACK;
 }
 
 /* A few different ideas for displaying boards:
@@ -367,23 +367,23 @@ loa_board_to_string (loa_board_t *board)
 } while (0)
 
     APPENDF (" %s\n", board_header);
-    for (y = 0; y < BOARD_SIZE; y++) {
-       APPENDF ("%d%s", BOARD_SIZE - y, row_header);
-       for (x = 0; x < BOARD_SIZE; x++) {
+    for (y = 0; y < LOA_BOARD_SIZE; y++) {
+       APPENDF ("%d%s", LOA_BOARD_SIZE - y, row_header);
+       for (x = 0; x < LOA_BOARD_SIZE; x++) {
            APPENDF ("%s", cell_strings[board->cells[x][y]]);
-           if (x != BOARD_SIZE - 1)
+           if (x != LOA_BOARD_SIZE - 1)
                APPENDF ("%s", cell_separator);
        }
        APPENDF ("%s\n", row_footer);
-       if (y != BOARD_SIZE -1)
+       if (y != LOA_BOARD_SIZE -1)
            APPENDF (" %s\n", row_separator);
     }
     APPENDF (" %s\n", board_footer);
 
     APPENDF ("   ");
-    for (x = 0; x < BOARD_SIZE; x++) {
+    for (x = 0; x < LOA_BOARD_SIZE; x++) {
        APPENDF ("%c", 'A' + x);
-       if (x != BOARD_SIZE - 1)
+       if (x != LOA_BOARD_SIZE - 1)
            APPENDF ("   ");
     }
     APPENDF ("\n");
@@ -402,10 +402,10 @@ loa_game_move (loa_game_t *game, const char * peer,
               int x1, int y1, int x2, int y2)
 {
     loa_board_t *board = &game->board;
-    cell_t cell;
+    loa_cell_t cell;
     char *error;
 
-    if (x1 < 0 || y1 < 0 || x1 >= BOARD_SIZE || y1 >= BOARD_SIZE) {
+    if (x1 < 0 || y1 < 0 || x1 >= LOA_BOARD_SIZE || y1 >= LOA_BOARD_SIZE) {
        loudgame_sendf (&game->lg, peer, "Invalid coordinates (not on board).");
        return FALSE;
     }
@@ -418,8 +418,8 @@ loa_game_move (loa_game_t *game, const char * peer,
 
     if (! loa_board_move_legal (&game->board, x1, y1, x2, y2, &error)) {
        loudgame_sendf (&game->lg, peer, "Illegal move: %c%d%c%d",
-                       'a' + x1, BOARD_SIZE - y1,
-                       'a' + x2, BOARD_SIZE - y2);
+                       'a' + x1, LOA_BOARD_SIZE - y1,
+                       'a' + x2, LOA_BOARD_SIZE - y2);
        return FALSE;
     }
 
@@ -453,7 +453,7 @@ loa_game_handle_show (loa_game_t *game,
                                   "xmlns",
                                   "http://www.w3.org/1999/xhtml");
 
-    if (game->board.player == PLAYER_BLACK)
+    if (game->board.player == LOA_PLAYER_BLACK)
        lm_message_node_add_child (body, "span", "Black to move:");
     else
        lm_message_node_add_child (body, "span", "White to move:");
@@ -505,14 +505,14 @@ loa_game_handle_move (loa_game_t *game,
     x1 = tolower (xc1) - 'a';
     x2 = tolower (xc2) - 'a';
     /* We use an upper-left origin internally. */
-    y1 = BOARD_SIZE - y1;
-    y2 = BOARD_SIZE - y2;
+    y1 = LOA_BOARD_SIZE - y1;
+    y2 = LOA_BOARD_SIZE - y2;
     if (! loa_game_move (game, peer, x1, y1, x2, y2))
        return;
 
     loudgame_broadcastf (&game->lg, "%c%d%c%d",
-                        'a' + x1, BOARD_SIZE - y1,
-                        'a' + x2, BOARD_SIZE - y2);
+                        'a' + x1, LOA_BOARD_SIZE - y1,
+                        'a' + x2, LOA_BOARD_SIZE - y2);
 
     if (loa_board_is_won (&game->board, x2, y2))
        loudgame_broadcastf (&game->lg, "%s wins", peer);