X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;ds=sidebyside;f=lg-loa.c;h=0d582c9def03412357aaa4ede5c58476ece221ed;hb=1e88be4305a8492e7343ba03456f93e4b1044c27;hp=f6a8f4c182e10811b093ed1bf5651fe09779463f;hpb=76ee71f47307291d8d2457204fc7c44b93729bb9;p=loudgame

diff --git a/lg-loa.c b/lg-loa.c
index f6a8f4c..0d582c9 100644
--- a/lg-loa.c
+++ b/lg-loa.c
@@ -64,18 +64,28 @@ typedef struct {
     int col_pieces[BOARD_SIZE];
     int diag_grave_pieces[DIAG_ARRAY_SIZE];
     int diag_acute_pieces[DIAG_ARRAY_SIZE];
-} board_t;
+
+    player_t player;
+} loa_board_t;
 
 typedef struct _loa_game {
     loudgame_t lg;
-    board_t board;
-    player_t current;
+    loa_board_t board;
 } loa_game_t;
 
+static void
+loa_board_next_player (loa_board_t *board)
+{
+    if (board->player == PLAYER_BLACK)
+	board->player = PLAYER_WHITE;
+    else
+	board->player = PLAYER_BLACK;
+}
+
 static int
-board_group_size_recursive (board_t *board, int x, int y,
-			    cell_t cell,
-			    uint64_t *visited)
+loa_board_group_size_recursive (loa_board_t *board, int x, int y,
+				cell_t cell,
+				uint64_t *visited)
 {
     uint64_t bit;
 
@@ -95,35 +105,35 @@ board_group_size_recursive (board_t *board, int x, int y,
 	return 0;
 
     return 1 +
-	board_group_size_recursive (board, x-1, y-1, cell, visited) +
-	board_group_size_recursive (board, x-1, y  , cell, visited) +
-	board_group_size_recursive (board, x-1, y+1, cell, visited) +
-	board_group_size_recursive (board, x  , y-1, cell, visited) +
-	board_group_size_recursive (board, x  , y  , cell, visited) +
-	board_group_size_recursive (board, x  , y+1, cell, visited) +
-	board_group_size_recursive (board, x+1, y-1, cell, visited) +
-	board_group_size_recursive (board, x+1, y  , cell, visited) +
-	board_group_size_recursive (board, x+1, y+1, cell, visited);
+	loa_board_group_size_recursive (board, x-1, y-1, cell, visited) +
+	loa_board_group_size_recursive (board, x-1, y  , cell, visited) +
+	loa_board_group_size_recursive (board, x-1, y+1, cell, visited) +
+	loa_board_group_size_recursive (board, x  , y-1, cell, visited) +
+	loa_board_group_size_recursive (board, x  , y  , cell, visited) +
+	loa_board_group_size_recursive (board, x  , y+1, cell, visited) +
+	loa_board_group_size_recursive (board, x+1, y-1, cell, visited) +
+	loa_board_group_size_recursive (board, x+1, y  , cell, visited) +
+	loa_board_group_size_recursive (board, x+1, y+1, cell, visited);
 }
 
 static int
-board_group_size (board_t *board, int x, int y)
+loa_board_group_size (loa_board_t *board, int x, int y)
 {
     uint64_t visited = 0ll;
     cell_t cell = board->cells[x][y];
 
-    return board_group_size_recursive (board, x, y, cell, &visited);
+    return loa_board_group_size_recursive (board, x, y, cell, &visited);
 }
 
 static int
-board_is_won (board_t *board, int x, int y)
+loa_board_is_won (loa_board_t *board, int x, int y)
 {
     cell_t cell = board->cells[x][y];
 
     if (cell == CELL_EMPTY)
 	return 0;
 
-    if (board_group_size (board, x, y) == board->num_pieces[cell])
+    if (loa_board_group_size (board, x, y) == board->num_pieces[cell])
 	return 1;
 
     return 0;
@@ -154,7 +164,10 @@ _acute_index (int x, int y)
 }
 
 static loa_bool_t
-board_move_legal (board_t *board, int x1, int y1, int x2, int y2, char **error)
+loa_board_move_legal (loa_board_t *board,
+		      int x1, int y1,
+		      int x2, int y2,
+		      char **error)
 {
     int x, y;
     int dx, dy;
@@ -227,7 +240,7 @@ board_move_legal (board_t *board, int x1, int y1, int x2, int y2, char **error)
 }
 
 static void
-board_add_piece (board_t *board, int x, int y, cell_t cell)
+loa_board_add_piece (loa_board_t *board, int x, int y, cell_t cell)
 {
     assert (cell == CELL_BLACK || cell == CELL_WHITE);
     assert (board->cells[x][y] == CELL_EMPTY);
@@ -243,7 +256,7 @@ board_add_piece (board_t *board, int x, int y, cell_t cell)
 }
 
 static cell_t
-board_remove_piece (board_t *board, int x, int y)
+loa_board_remove_piece (loa_board_t *board, int x, int y)
 {
     cell_t cell;
 
@@ -265,7 +278,7 @@ board_remove_piece (board_t *board, int x, int y)
 }
 
 static void
-board_init (board_t *board)
+loa_board_init (loa_board_t *board)
 {
     int i, x, y;
 
@@ -287,11 +300,13 @@ board_init (board_t *board)
     }
 
     for (i = 1; i < BOARD_SIZE - 1; i++) {
-	board_add_piece (board, i, 0, CELL_BLACK);
-	board_add_piece (board, i, BOARD_SIZE - 1, CELL_BLACK);
-	board_add_piece (board, 0, i, CELL_WHITE);
-	board_add_piece (board, BOARD_SIZE - 1, i, CELL_WHITE);
+	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);
     }
+
+    board->player = PLAYER_BLACK;
 }
 
 /* A few different ideas for displaying boards:
@@ -326,7 +341,7 @@ board_init (board_t *board)
  *    A   B   C   D   E   F   G   H  	   A   B   C   D   E   F   G   H
  */
 static char *
-board_to_string (board_t *board)
+loa_board_to_string (loa_board_t *board)
 {
     int x, y;
     /* In order of BLACK, WHITE, EMPTY */
@@ -379,24 +394,14 @@ board_to_string (board_t *board)
 static void
 loa_game_new_game (loa_game_t *game)
 {
-    board_init (&game->board);
-    game->current = PLAYER_BLACK;
-}
-
-static void
-loa_game_next_player (loa_game_t *game)
-{
-    if (game->current == PLAYER_BLACK)
-	game->current = PLAYER_WHITE;
-    else
-	game->current = PLAYER_BLACK;
+    loa_board_init (&game->board);
 }
 
 static loa_bool_t
 loa_game_move (loa_game_t *game, const char * peer,
 	       int x1, int y1, int x2, int y2)
 {
-    board_t *board = &game->board;
+    loa_board_t *board = &game->board;
     cell_t cell;
     char *error;
 
@@ -405,22 +410,24 @@ loa_game_move (loa_game_t *game, const char * peer,
 	return FALSE;
     }
 
-    if (board->cells[x1][y1] != game->current) {
+    if (board->cells[x1][y1] != board->player) {
 	loudgame_sendf (&game->lg, peer, "Cell at (%d,%d) does not belong to current player.",
 			x1, y1);
 	return FALSE;
     }
 
-    if (! board_move_legal (&game->board, x1, y1, x2, y2, &error)) {
-	loudgame_sendf (&game->lg, peer, "Illegal move: %s.");
+    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);
 	return FALSE;
     }
 
-    cell = board_remove_piece (board, x1, y1);
-    board_remove_piece (board, x2, y2);
-    board_add_piece (board, x2, y2, cell);
+    cell = loa_board_remove_piece (board, x1, y1);
+    loa_board_remove_piece (board, x2, y2);
+    loa_board_add_piece (board, x2, y2, cell);
 
-    loa_game_next_player (game);
+    loa_board_next_player (board);
 
     return TRUE;
 }
@@ -446,12 +453,12 @@ loa_game_handle_show (loa_game_t *game,
 				   "xmlns",
 				   "http://www.w3.org/1999/xhtml");
 
-    if (game->current == PLAYER_BLACK)
+    if (game->board.player == PLAYER_BLACK)
 	lm_message_node_add_child (body, "span", "Black to move:");
     else
 	lm_message_node_add_child (body, "span", "White to move:");
 
-    board_string = board_to_string (&game->board);
+    board_string = loa_board_to_string (&game->board);
 
     line = board_string;
     while (1) {
@@ -507,7 +514,7 @@ loa_game_handle_move (loa_game_t *game,
 			 'a' + x1, BOARD_SIZE - y1,
 			 'a' + x2, BOARD_SIZE - y2);
 
-    if (board_is_won (&game->board, x2, y2))
+    if (loa_board_is_won (&game->board, x2, y2))
 	loudgame_broadcastf (&game->lg, "%s wins", peer);
 }
 
@@ -516,7 +523,7 @@ loa_game_handle_pass (loa_game_t *game, const char *peer)
 {
     loudgame_broadcastf (&game->lg, "%s passes", peer);
 
-    loa_game_next_player (game);
+    loa_board_next_player (&game->board);
 }
 
 static void