move history

uttt.c

@@ -28,6 +28,15 @@ const struct ut_state ut_initial = {
 		.playBoard = -1,
 		.player = 'X',
 };
+struct ut_move
+{
+	char r, c;
+};
+struct ut_game
+{
+	char l;
+	struct ut_move moves[81];
+};
 
 const char HELP_TEXT[] = "\
 Usage: uttt (--local | --host | --join)\n\
@@ -59,7 +68,7 @@ char ut_turn(char player)
 }
 
 #define T(r, c) (tiles[offset + stride * r + c])
-char ut_winner(const char *tiles, int offset, int stride) {
+char ut_winnerBoard(const char *tiles, int offset, int stride) {
 
 	// whoreizontal wins
 	for (int y = 0; y < 3; y++)
@@ -94,31 +103,38 @@ char ut_winner(const char *tiles, int offset, int stride) {
 	}
 	return ' '; // draw
 }
+char ut_winner(const struct ut_state *state)
+{
+	return ut_winnerBoard((char *)state->boards, 0, 3);
+}
 
-int ut_move(struct ut_state *new_state, const struct ut_state *old_state, int row, int col)
+int ut_move(struct ut_state *new_state, const struct ut_state *old_state, struct ut_move m)
 {
 	// bad move - out of bounds
-	if(row < 0 || row >= 9 || col < 0 || col >= 9) {return 1;}
+	if(m.r < 0 || m.r >= 9 || m.c < 0 || m.c >= 9) {return 1;}
 
 	// state->playBoard == -1 means all boards playable; otherwise only one board is playable
-	if (old_state->playBoard != -1 && old_state->playBoard != 3 * (row / 3) + (col / 3)) {return 1;}
+	if (old_state->playBoard != -1 && old_state->playBoard != 3 * (m.r / 3) + (m.c / 3)) {return 1;}
 
 	// bad move - tile is occupied
-	if(old_state->tiles[row][col] != '\0') {return 1;}
+	if(old_state->tiles[m.r][m.c] != '\0') {return 1;}
 
 	// bad move - board is finished
-	if(old_state->boards[row / 3][col / 3] != '\0') {return 1;}
+	if(old_state->boards[m.r / 3][m.c / 3] != '\0') {return 1;}
+
+	// just check if move valid
+	if(!new_state) {return 0;}
 
 	// copy old_state->{tiles,boards} to new_state->{tiles,boards}
 	memmove(new_state->tiles, old_state->tiles, sizeof(old_state->tiles));
 	memmove(new_state->boards, old_state->boards, sizeof(old_state->boards));
 
 	// do move
-	new_state->tiles[row][col] = old_state->player;
-	new_state->boards[row / 3][col / 3] = ut_winner((char *)new_state->tiles, 27 * (row / 3) + 3 * (col / 3), 9);
+	new_state->tiles[m.r][m.c] = old_state->player;
+	new_state->boards[m.r / 3][m.c / 3] = ut_winnerBoard((char *)new_state->tiles, 27 * (m.r / 3) + 3 * (m.c / 3), 9);
 
 	//  next play board - if next play board is not playable, play any board
-	new_state->playBoard = new_state->boards[row % 3][col % 3] == '\0' ? 3 * (row % 3) + (col % 3) : -1;
+	new_state->playBoard = new_state->boards[m.r % 3][m.c % 3] == '\0' ? 3 * (m.r % 3) + (m.c % 3) : -1;
 
 	new_state->player = ut_turn(old_state->player);
 	return 0;
@@ -208,7 +224,7 @@ void ut_drawBoard(void (*mvch)(void*, int, int, char), void *arg, const char *ti
 }
 #define DTILES_Y 21
 #define DTILES_X 21
-void ut_drawTiles(void (*mvch)(void*, int, int, char), void *arg, const struct ut_state *state, bool numbers, int lr, int lc)
+void ut_drawTiles(void (*mvch)(void*, int, int, char), void *arg, const struct ut_state *state, bool numbers, struct ut_move lm)
 {
 	for(int r = 0; r < 3; r++)
 		for(int c = 0; c < 3; c++)
@@ -226,10 +242,10 @@ void ut_drawTiles(void (*mvch)(void*, int, int, char), void *arg, const struct u
 			for(int r = 0; r < 3; r++)
 				mvch(arg, 7 * b + 2 * r + 1, 0, '0' + 3 * b + r);
 	}
-	if(lr >= 0 && lr < 9 && lc >= 0 && lc < 9)
-		mvch(arg, 7 * (lr / 3) + 2 * (lr % 3) + 1,
-			  7 * (lc / 3) + 2 * (lc % 3) + 1,
-			  state->tiles[lr][lc] == 'X' ? '%' : '0');
+	if(lm.r >= 0 && lm.r < 9 && lm.c >= 0 && lm.c < 9)
+		mvch(arg, 7 * (lm.r / 3) + 2 * (lm.r % 3) + 1,
+			  7 * (lm.c / 3) + 2 * (lm.c % 3) + 1,
+			  state->tiles[lm.r][lm.c] == 'X' ? '%' : '0');
 }
 #define DBOARDS_Y 7
 #define DBOARDS_X 7
@@ -269,33 +285,45 @@ void ut_bmvch(void *arg, int y, int x, char c)
 }
 
 int dtiles_line;
-void ut_cursdraw(const struct ut_state *state)
+void ut_cursdraw(const struct ut_state *state, const struct ut_game *game)
 {
 	ut_cursprintf("Turn: %c  Play board: %s\n", (int)state->player, PLAY_BOARDS[(state->playBoard + 10) % 10]);
 	dtiles_line = curs_line;
-	ut_drawTiles(ut_cursmvchc, NULL, state, false, -1, -1); // TODO some kind of move history to know the last move
+	ut_drawTiles(ut_cursmvchc, NULL, state, false, (game && game->l > 0) ? game->moves[game->l - 1] : (struct ut_move){-1, -1});
 	curs_line += DTILES_Y;
 	//ut_drawBoards(ut_cursmvchc, NULL, state);
 }
-void ut_sockdraw(const struct ut_state *state, int fd)
+void ut_sockdraw(const struct ut_state *state, const struct ut_game *game, int fd)
 {
 	ut_dprintf(fd, "Turn: %c\nPlay board: %s\n", (int)state->player, PLAY_BOARDS[(state->playBoard + 10) % 10]);
 	char dtiles[DTILES_Y][DTILES_X];
-	ut_drawTiles(ut_tmvch, dtiles, state, true, -1, -1);
+	ut_drawTiles(ut_tmvch, dtiles, state, true, (game && game->l > 0) ? game->moves[game->l - 1] : (struct ut_move){-1, -1});
 	for(int r = 0; r < DTILES_Y; r++)
 	{
 		ut_dprintf(fd, "%.*s\n", DTILES_X, dtiles[r]);
 	}
 }
 
-/*void ut_show_boards(const struct ut_state *state) {
-	for (int j = 0; j < 3; j++) {
-		for (int i = 0; i < 3; i++) {
-			putchar(state->boards[j][i] ? state->boards[j][i] : ' ');
+void ut_cursmove(const struct ut_move m)
+{
+	ut_cursprintf("%d,%d", (int)m.c, (int)m.r);
+}
+void ut_cursgame(const struct ut_game *game)
+{
+	for(int i = 0; i < game->l; i++)
+	{
+		ut_cursmove(game->moves[i]);
+		if(i + 1 < game->l)
+		{
+			ut_cursprintf(" ");
 		}
-		putchar('\n');
 	}
-}*/
+	ut_cursprintf("\n");
+}
+void ut_sockmove(const struct ut_move m, int fd)
+{
+	ut_dprintf(fd, "%d,%d\n", (int)m.c, (int)m.r);
+}
 
 int ut_readfill(int fd, char *x, size_t l)
 {
@@ -314,35 +342,35 @@ int ut_readfill(int fd, char *x, size_t l)
 	return 0;
 }
 
-int ut_cursgetpos(const struct ut_state *state, int *r, int *c)
+int ut_cursgetmove(const struct ut_state *state, struct ut_move *m)
 {
 #define P(r, c, d) ((state->playBoard == -1 || state->playBoard == 3 * (r / 3) + (c / 3)) && \
 	            (state->boards[r / 3][c / 3] == '\0' || d % 3 == 1))
 	MEVENT event;
 	ut_cursprintf("Select move with arrow keys or mouse.\n");
-	if(*r < 0 || *r >= 9 || *c < 0 || *c >= 9)
+	if(m->r < 0 || m->r >= 9 || m->c < 0 || m->c >= 9)
 	{
-		*r = 4; *c = 4;
+		m->r = 4; m->c = 4;
 	}
 	else if(state->playBoard == -1)
 	{
-		*r = 3 * (*r / 3) + 1;
-		*c = 3 * (*c / 3) + 1;
+		m->r = 3 * (m->r / 3) + 1;
+		m->c = 3 * (m->c / 3) + 1;
 	}
 	else
 	{
-		*r = 3 * (state->playBoard / 3) + 1;
-		*c = 3 * (state->playBoard % 3) + 1;
+		m->r = 3 * (state->playBoard / 3) + 1;
+		m->c = 3 * (state->playBoard % 3) + 1;
 	}
 	for(;;)
 	{
-		/*if(state->boards[*r / 3][*c / 3] != '\0')
+		/*if(state->boards[m->r / 3][m->c / 3] != '\0')
 		{
-			*r = 3 * (*r / 3) + 1;
-			*c = 3 * (*c / 3) + 1;
+			m->r = 3 * (m->r / 3) + 1;
+			m->c = 3 * (m->c / 3) + 1;
 		}*/
-		move(dtiles_line + (7 * (*r / 3) + 1) + (2 * (*r % 3)),
-		     (7 * (*c / 3) + 1) + (2 * (*c % 3)));
+		move(dtiles_line + (7 * (m->r / 3) + 1) + (2 * (m->r % 3)),
+		     (7 * (m->c / 3) + 1) + (2 * (m->c % 3)));
 		refresh();
 		switch(getch())
 		{
@@ -352,8 +380,8 @@ int ut_cursgetpos(const struct ut_state *state, int *r, int *c)
 					event.y -= dtiles_line;
 					if(event.y < 0 || event.y >= 21) {break;}
 					if(event.x < 0 || event.x >= 21) {break;}
-					*r = (event.y % 7 - 1) / 2 + 3 * (event.y / 7);
-					*c = (event.x % 7 - 1) / 2 + 3 * (event.x / 7);
+					m->r = (event.y % 7 - 1) / 2 + 3 * (event.y / 7);
+					m->c = (event.x % 7 - 1) / 2 + 3 * (event.x / 7);
 					if(((event.y % 7) - 1) % 2 != 0) {break;}
 					if(((event.x % 7) - 1) % 2 != 0) {break;}
 					return 0;
@@ -362,41 +390,41 @@ int ut_cursgetpos(const struct ut_state *state, int *r, int *c)
 			case 'k':  /* FALLTHROUGH */
 			case 'w':  /* FALLTHROUGH */
 			case KEY_UP:
-				//*r = (((*r - 1) % 9) + 9) % 9;
+				//m->r = (((m->r - 1) % 9) + 9) % 9;
 				for(int i = 0; i < 9 + 1; i++)
 				{
-					*r = (*r + 9 - 1) % 9;
-					if(P(*r, *c, *r)) {break;}
+					m->r = (m->r + 9 - 1) % 9;
+					if(P(m->r, m->c, m->r)) {break;}
 				}
 				break;
 			case 'h':  /* FALLTHROUGH */
 			case 'a':  /* FALLTHROUGH */
 			case KEY_LEFT:
-				//*c = (((*c - 1) % 9) + 9) % 9;
+				//m->c = (((m->c - 1) % 9) + 9) % 9;
 				for(int i = 0; i < 9 + 1; i++)
 				{
-					*c = (*c + 9 - 1) % 9;
-					if(P(*r, *c, *c)) {break;}
+					m->c = (m->c + 9 - 1) % 9;
+					if(P(m->r, m->c, m->c)) {break;}
 				}
 				break;
 			case 'j':  /* FALLTHROUGH */
 			case 's':  /* FALLTHROUGH */
 			case KEY_DOWN:
-				//*r = (*r + 1) % 9;
+				//m->r = (m->r + 1) % 9;
 				for(int i = 0; i < 9 + 1; i++)
 				{
-					*r = (*r + 1) % 9;
-					if(P(*r, *c, *r)) {break;}
+					m->r = (m->r + 1) % 9;
+					if(P(m->r, m->c, m->r)) {break;}
 				}
 				break;
 			case 'l':  /* FALLTHROUGH */
 			case 'd':  /* FALLTHROUGH */
 			case KEY_RIGHT:
-				//*c = (*c + 1) % 9;
+				//m->c = (m->c + 1) % 9;
 				for(int i = 0; i < 9 + 1; i++)
 				{
-					*c = (*c + 1) % 9;
-					if(P(*r, *c, *c)) {break;}
+					m->c = (m->c + 1) % 9;
+					if(P(m->r, m->c, m->c)) {break;}
 				}
 				break;
 			case ' ':  /* FALLTHROUGH */
@@ -411,36 +439,6 @@ int ut_cursgetpos(const struct ut_state *state, int *r, int *c)
 #undef P
 }
 
-/*bool getpos(const struct ut_state *state, int *x, int *y) {
-	while (true) {
-		printf("Place token %c at position x,y: ", state->player);
-		char line[5] = {0};
-		if (fgets(line, 5, stdin) == NULL)
-			return false;
-		// line was too short
-		if (line[3] == '\0')
-			continue;
-		// line was too long
-		if (line[3] != '\n') {
-			// consume rest of line
-			while (true) {
-				int garbage = getchar();
-				if (garbage == EOF)
-					return false;
-				if (garbage == '\n')
-					break;
-			}
-			continue;
-		}
-		int sscanf_result = sscanf(line, "%d,%d", x, y);
-		if (sscanf_result == EOF)
-			return false;
-		if (sscanf_result != 2)
-			continue;
-		break;
-	}
-	return true;
-}*/
 
 int ut_ignore_line(int sock) {
 	char byte;
@@ -453,7 +451,7 @@ int ut_ignore_line(int sock) {
 	return 2;
 }
 
-int ut_sockgetpos(const struct ut_state *state, int sock, int *y, int *x, bool readable) { // TODO
+int ut_sockgetmove(const struct ut_state *state, int sock, struct ut_move *m, bool readable) {
 	int index = 0;
 	char byte;
 	while (true) {
@@ -465,9 +463,9 @@ int ut_sockgetpos(const struct ut_state *state, int sock, int *y, int *x, bool r
 		if (index == 0 && byte == '|') {
 			if (ut_ignore_line(sock)) {return -1;}
 		} else if (index == 0) {
-			*x = byte - 0x30;
+			m->c = byte - 0x30;
 		} else if (index == 2) {
-			*y = byte - 0x30;
+			m->r = byte - 0x30;
 		} else if (index == 1 && byte != ',' || index == 3 && byte != '\n') {
 			ut_cursprintf("Partner sent malformed coords - retrying\n");
 			if (ut_ignore_line(sock)) {return 2;}
@@ -480,17 +478,17 @@ int ut_sockgetpos(const struct ut_state *state, int sock, int *y, int *x, bool r
 		index++;
 		if (index == 4) {break;}
 	}
-	//printf("x=%d y=%d\n", *x, *y);
+	//printf("x=%d y=%d\n", (int)m->c, (int)m->r);
 	return 0;
 }
 
-int ut_local_game(struct ut_state *state) {
+int ut_local_game(struct ut_state *state, struct ut_game *game) {
 	for(;;)
 	{
-		int r = 4, c = 4;
+		struct ut_move m = {4, 4};
 		ut_curserase();
-		ut_cursdraw(state);
-		char w = ut_winner((char *)state->boards, 0, 3);
+		ut_cursdraw(state, game);
+		char w = ut_winner(state);
 		if(w)
 		{
 			if(w == ' ')
@@ -503,19 +501,20 @@ int ut_local_game(struct ut_state *state) {
 			}
 			break;
 		}
-		if(ut_cursgetpos(state, &r, &c)) {continue;}
-		if(ut_move(state, state, r, c)) {continue;}
+		if(ut_cursgetmove(state, &m)) {continue;}
+		if(ut_move(state, state, m)) {continue;}
+		game->moves[game->l++] = m;
 	}
 	return 0;
 }
 
-int ut_network_game(struct ut_state *state, int sock, char player, bool readable) { // TODO
+int ut_network_game(struct ut_state *state, struct ut_game *game, int sock, char player, bool readable) {
 	while (true) {
-		int r = 4, c = 4;
+		struct ut_move m = {4, 4};
 		ut_curserase();
-		ut_cursdraw(state);
-		if (readable) ut_sockdraw(state, sock);
-		char w = ut_winner((char *)state->boards, 0, 3);
+		ut_cursdraw(state, game);
+		if (readable) ut_sockdraw(state, game, sock);
+		char w = ut_winner(state);
 		if(w)
 		{
 			if(w == ' ')
@@ -534,17 +533,22 @@ int ut_network_game(struct ut_state *state, int sock, char player, bool readable
 		}
 		if (state->player == player) {
 			if (readable) {ut_dprintf(sock, "Waiting for game partner ...\n");}
-			if(ut_cursgetpos(state, &r, &c)) {continue;}
-			ut_dprintf(sock, "%d,%d\n", c, r);
+			if(ut_cursgetmove(state, &m)) {continue;}
+			ut_sockmove(m, sock);
 		} else {
 			ut_cursprintf("Waiting for game partner ...\n");
 			refresh();
 			if (readable) {
 				// line feed aligns game board each turn
-				ut_dprintf(sock, "\nPlace token %c in position x,y: ", ut_turn(player));
+				ut_dprintf(sock, "\nPlace token %c in position x,y: ", (int)ut_turn(player));
+			}
+			int err = ut_sockgetmove(state, sock, &m, readable);
+			if(err != 0)
+			{
+				ut_cursprintf("received ");
+				ut_cursmove(m);
+				ut_cursprintf("\n");
 			}
-			int err = ut_sockgetpos(state, sock, &r, &c, readable);
-			ut_cursprintf("received row=%d col=%d\n", r, c);
 			if (err == 1) {
 				ut_cursprintf("Connection closed.\n");
 				return 1;
@@ -554,8 +558,9 @@ int ut_network_game(struct ut_state *state, int sock, char player, bool readable
 				return 1;
 			}
 		}
-		if (ut_move(state, state, r, c)) {continue;}
 		if (readable) {ut_dprintf(sock, "\n");}
+		if (ut_move(state, state, m)) {continue;}
+		game->moves[game->l++] = m;
 	}
 	return 0;
 }
@@ -568,10 +573,10 @@ char ut_random_player(void) {
 	return player;
 }
 
-int ut_host_game(struct ut_state *state) {
+int ut_host_game(struct ut_state *state, struct ut_game *game) {
 	int sock = socket(AF_INET, SOCK_STREAM, 0);
 	if (sock == -1) {
-		printf("error %d\n", errno);
+		ut_cursprintf("error %d\n", errno);
 		return 1;
 	}
 	const struct sockaddr_in addr = {
@@ -581,19 +586,21 @@ int ut_host_game(struct ut_state *state) {
 	};
 	setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &(int){1}, sizeof(int));
 	if (bind(sock, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
-		printf("error %d\n", errno);
+		ut_cursprintf("error %d\n", errno);
 		return 1;
 	}
 	if (listen(sock, 128) == -1) {
-		printf("error %d\n", errno);
+		ut_cursprintf("error %d\n", errno);
 		return 1;
 	}
 	ut_cursprintf("Waiting for game partner at 127.0.0.1:6669 ...\n");
+	refresh();
 	int conn = accept(sock, NULL, NULL);
 	if (conn == -1) {
-		printf("error %d\n", errno);
+		ut_cursprintf("error %d\n", errno);
 		return 1;
 	}
+	close(sock);
 
 	// decide X or O
 	char player;
@@ -603,34 +610,34 @@ int ut_host_game(struct ut_state *state) {
 	char byte;
 	ut_dprintf(conn, "| Press enter to start.\n");
 	if (ut_readfill(conn, &byte, 1)) {
-		printf("Connection closed.\n");
+		ut_cursprintf("Connection closed.\n");
 		return 1;
 	}
-	bool readable = byte != '\0';
+	bool readable = (byte != '\0');
 	if (byte != '\n') {
 		int err = ut_ignore_line(conn);
 		if (err == 1) {
-			printf("Connection closed.\n");
+			ut_cursprintf("Connection closed.\n");
 			return 1;
 		} else if (err == 2) {
-			printf("Partner sent too much data - exiting\n");
+			ut_cursprintf("Partner sent too much data - exiting\n");
 			return 1;
 		}
 	}
 
 	// tell partner X or O
-	ut_dprintf(conn, "%c\n", ut_turn(player));
+	ut_dprintf(conn, "%c\n", (int)ut_turn(player));
 	if (readable) {
 		ut_dprintf(conn, "You play as: %c\n\n", ut_turn(player));
 	}
 
-	return ut_network_game(state, conn, player, readable);
+	return ut_network_game(state, game, conn, player, readable);
 }
 
-int ut_join_game(struct ut_state *state) {
+int ut_join_game(struct ut_state *state, struct ut_game *game) {
 	int sock = socket(AF_INET, SOCK_STREAM, 0);
 	if (sock == -1) {
-		printf("error %d\n", errno);
+		ut_cursprintf("error %d\n", errno);
 		return 1;
 	}
 	const struct sockaddr_in addr = {
@@ -639,9 +646,10 @@ int ut_join_game(struct ut_state *state) {
 		.sin_addr = { .s_addr = htonl(0x7f000001) },
 	};
 	ut_cursprintf("Connecting to game host at 127.0.0.1:6669 ...\n");
+	refresh();
 	if(connect(sock, (struct sockaddr*)&addr, sizeof(addr)) == -1)
 	{
-		printf("error %d\n", errno);
+		ut_cursprintf("error %d\n", errno);
 		return 1;
 	}
 
@@ -649,24 +657,23 @@ int ut_join_game(struct ut_state *state) {
 	ut_writefill(sock, "\0\n", 2);
 
 	// host decides X or O
-	char player_buf[2];
-	char *player = player_buf;
+	char player[2];
 	for (int i = 0; i < 10; i++) {
-		int r = ut_readfill(sock, player_buf, 1);
+		int r = ut_readfill(sock, player, 1);
 		ut_ignore_line(sock);
 		if (*player == '|') {
 			continue;
 		}
-		if (r == 2) {printf("Connection closed.\n");}
+		if (r == 2) {ut_cursprintf("Connection closed.\n");}
 		if (r != 0) {return 1;}
 		break;
 	}
 	if (*player != 'X' && *player != 'O') {
-		printf("Host is retarded.\n");
+		ut_cursprintf("Host is retarded.\n");
 		return 1;
 	}
 
-	return ut_network_game(state, sock, *player, false);
+	return ut_network_game(state, game, sock, *player, false);
 }
 
 void finish(int sig)
@@ -704,18 +711,19 @@ void begin(void)
 int main(int argc, char **argv) {
 
 	struct ut_state state = ut_initial;
+	struct ut_game game = {0};
 	if (argc != 2) {
 		printf(HELP_TEXT);
 		return 1;
 	} else if (strncmp(argv[1], arg_local, sizeof(arg_local)) == 0) {
 		begin();
-		waitfinish(ut_local_game(&state));
+		waitfinish(ut_local_game(&state, &game));
 	} else if (strncmp(argv[1], arg_host, sizeof(arg_host)) == 0) {
 		begin();
-		waitfinish(ut_host_game(&state));
+		waitfinish(ut_host_game(&state, &game));
 	} else if (strncmp(argv[1], arg_join, sizeof(arg_join)) == 0) {
 		begin();
-		waitfinish(ut_join_game(&state));
+		waitfinish(ut_join_game(&state, &game));
 	} else {
 		printf(HELP_TEXT);
 		return 1;