uttt/uttt.c

#include <stddef.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curses.h>
#include <signal.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <errno.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

struct ut_state
{
	char tiles[9][9];
	char boards[3][3];
	int playBoard;
	char player;
};
const struct ut_state ut_initial = {
		.boards = {0},
		.tiles = {0},
		.playBoard = -1,
		.player = 'X'
	};

const char *arg_host = "--host";
const char *arg_join = "--join";

char ut_turn(char player)
{
	switch(player)
	{
		case 'X': return 'O';
		case 'O': return 'X';
		default: return '\0';
	}
}

#define T(r, c) (tiles[offset + stride * r + c])
char ut_winner(char *tiles, int offset, int stride) {

	// whoreizontal wins
	for (int y = 0; y < 3; y++)
	{
		char tile = T(y, 0);
		if (tile == '\0') {continue;}
		if (tile == T(y, 1) && tile == T(y, 2)) {return tile;}
	}

	// vertical wins
	for (int x = 0; x < 3; x++)
	{
		char tile = T(0, x);
		if (tile == '\0') {continue;}
		if (tile == T(1, x) && tile == T(2, x)) {return tile;}
	}

	// diagonalz
	char tile = T(1, 1);
	if (tile != '\0')
	{
		if (tile == T(0, 0) && tile == T(2, 2)) {return tile;}
		if (tile == T(2, 0) && tile == T(0, 2)) {return tile;}
	}

	for(int y = 0; y < 3; y++)
	{
		for(int x = 0; x < 3; x++)
		{
			if(T(y, x) == '\0') {return '\0';} // in progress
		}
	}
	return ' '; // draw
}

int ut_move(struct ut_state *new_state, const struct ut_state *old_state, int row, int col)
{
	// bad move - out of bounds
	if(row < 0 || row >= 9 || col < 0 || col >= 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;}

	// bad move - tile is occupied
	if(old_state->tiles[row][col] != '\0') {return 1;} // replace with ' ' maybe

	// 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);

	//  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->player = ut_turn(old_state->player);
	return 0;
}

void ut_show(const struct ut_state *state) {
    #define tiles state->tiles
    printf("Turn: %c\nPlay board: %d\n", (int)state->player, state->playBoard);
	int play_board_row = -1;
	int play_board_col = -1;
	if (state->playBoard != -1) {
		play_board_row = state->playBoard / 3;
		play_board_col = state->playBoard % 3;
	}
	printf("  012 345 678\n");
    for(int y = 0; y < 9; y++)
    {
		if (y == 3 || y == 6) {
			printf("  ---+---+---\n");
		}
		printf("%d ", y);
        for(int x = 0; x < 9; x++)
        {
			if (x == 3 || x == 6) {
				putchar('|');
			}
			putchar(tiles[y][x] ? tiles[y][x] : ' ');
        }
		if (y / 3 == play_board_row || play_board_row == -1) {
			printf("<");
		}
        putchar('\n');
    }
	if (play_board_col == -1) {
		printf("  ^^^ ^^^ ^^^");
	} else {
		printf("  ");
		for (int i = 0; i < play_board_col; i++) {
			printf("    ");
		}
		printf("^^^");
	}
    putchar('\n');
    #undef tiles
}

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]);
		}
		putchar('\n');
	}
}

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;
}

bool getpos_net(const struct ut_state *state, int conn, int *x, int *y) {
	char buf[4];
	int n = recv(conn, &buf, 4, 0); // lazy way but idc
	printf("bytes received: %d\n", n);
	printf("buf=%s\n", buf);
	*x = buf[0] - 0x30;
	*y = buf[2] - 0x30;
	printf("x=%d y=%d\n", *x, *y);
	if (buf[1] != ',' || buf[3] != '\n' || *x >= 9 || *y >= 9 || *x < 0 || *y < 0) {
		printf("protocol not followed perfectly by partner - exiting\n");
		exit(1);
	}
}

void finish(int sig)
{
	putchar('\n');
	endwin();
	// other cleanup
	exit(0);
}

void ut_local_game(struct ut_state *state) {
	int x, y;
	while (true) {
		ut_show(state);
		ut_show_boards(state);
		bool ok = getpos(state, &x, &y);
		if (!ok) {continue;}
		int err = ut_move(state, state, x, y);
		if (err) {continue;}
		char w = ut_winner((char *)state->boards, 0, 3);
		if(w)
		{
			if(w == ' ')
			{
				printf("\nDraw!\n");
			}
			else
			{
				printf("\n%c wins!\n", (int)w);
			}
		}
	}
}

void ut_host_game(struct ut_state *state, int conn, char host_player) {
	int x, y;
	printf("You play as %c.\n", host_player);
	while (true) {
		ut_show(state);
		ut_show_boards(state);
		if (state->player == host_player) {
			bool ok = getpos(state, &x, &y);
			if (!ok) {continue;}
		} else {
			printf("Waiting for game parter ...\n");
			getpos_net(state, conn, &x, &y);
		}
		int err = ut_move(state, state, x, y);
		if (err) {continue;}
		char w = ut_winner((char *)state->boards, 0, 3);
		if(w)
		{
			if(w == ' ')
			{
				printf("\nDraw!\n");
			}
			else
			{
				printf("\n%c wins!\n", (int)w);
			}
		}
	}
}

int main(int argc, char **argv) {
	signal(SIGINT, finish);
	struct ut_state state = ut_initial;
	if (argc < 2) {
		ut_local_game(&state);
	} else if (strncmp(argv[1], arg_host, strlen(arg_host)) == 0) {
		int sock = socket(AF_INET, SOCK_STREAM, 0);
		if (sock == -1) {
			int errsv = errno;
			printf("error %d\n", errsv);
			return 1;
		}
		const struct sockaddr_in addr = {
			.sin_family = AF_INET,
			.sin_port = htons(6669),
			.sin_addr = { .s_addr = htonl(0x7f000001) },
		};
		setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &(int){1}, sizeof(int));
		if (bind(sock, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
			int errsv = errno;
			printf("error %d\n", errsv);
			return 1;
		}
		if (listen(sock, 128) == -1) {
			int errsv = errno;
			printf("error %d\n", errsv);
			return 1;
		}
		printf("Waiting for game partner at 127.0.0.1:6669 ...\n");
		int conn = accept(sock, NULL, NULL);
		if (conn == -1) {
			int errsv = errno;
			printf("error %d\n", errsv);
			return 1;
		}
		int random = open("/dev/urandom", O_RDONLY);
		int byte;
		read(random, &byte, 1);
		//printf("%d\n", byte);
		char host_player = byte % 2 == 0 ? 'X' : 'O';
		//printf("%c\n", host_player);
		ut_host_game(&state, conn, host_player);
	} else if (strncmp(argv[1], arg_join, strlen(arg_join)) == 0) {
		printf("no ;)\n");
	} else {
		printf("%s\n", argv[1]);
	}
	return 0;

}