2023-11-12 19:34:40 +09:00
|
|
|
#include <stddef.h>
|
|
|
|
#include <stdbool.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2023-11-12 19:57:13 +09:00
|
|
|
#include <curses.h>
|
2023-11-12 20:43:33 +09:00
|
|
|
#include <signal.h>
|
2023-11-12 22:31:24 +09:00
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
2023-11-13 00:05:26 +09:00
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <unistd.h>
|
2023-11-13 22:50:02 +09:00
|
|
|
#include <stdarg.h>
|
2023-11-12 19:34:40 +09:00
|
|
|
|
2023-11-12 19:57:13 +09:00
|
|
|
struct ut_state
|
2023-11-12 19:34:40 +09:00
|
|
|
{
|
2023-11-12 19:57:13 +09:00
|
|
|
char tiles[9][9];
|
|
|
|
char boards[3][3];
|
|
|
|
int playBoard;
|
|
|
|
char player;
|
2023-11-14 18:39:41 +09:00
|
|
|
char host_player;
|
2023-11-12 19:34:40 +09:00
|
|
|
};
|
2023-11-12 20:43:33 +09:00
|
|
|
const struct ut_state ut_initial = {
|
|
|
|
.boards = {0},
|
|
|
|
.tiles = {0},
|
|
|
|
.playBoard = -1,
|
2023-11-14 18:39:41 +09:00
|
|
|
.player = 'X',
|
|
|
|
.host_player = '\0',
|
2023-11-14 23:10:49 +09:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ut_socket_buffer {
|
|
|
|
int fd;
|
|
|
|
char *buf;
|
|
|
|
size_t len;
|
|
|
|
size_t start;
|
|
|
|
size_t stop;
|
|
|
|
};
|
2023-11-12 19:34:40 +09:00
|
|
|
|
2023-11-14 18:39:41 +09:00
|
|
|
const char *HELP_TEXT = "\
|
|
|
|
Usage: uttt (--local | --host | --join)\n\
|
|
|
|
\n\
|
|
|
|
--local play non-network game\n\
|
|
|
|
--host host game at 127.0.0.1:6669\n\
|
|
|
|
--join join game at 127.0.0.1:6669\n\
|
|
|
|
";
|
|
|
|
|
|
|
|
const char *arg_local = "--local";
|
2023-11-12 22:31:24 +09:00
|
|
|
const char *arg_host = "--host";
|
|
|
|
const char *arg_join = "--join";
|
2023-11-12 19:34:40 +09:00
|
|
|
|
2023-11-12 19:57:13 +09:00
|
|
|
char ut_turn(char player)
|
2023-11-12 19:34:40 +09:00
|
|
|
{
|
2023-11-12 19:57:13 +09:00
|
|
|
switch(player)
|
|
|
|
{
|
|
|
|
case 'X': return 'O';
|
|
|
|
case 'O': return 'X';
|
|
|
|
default: return '\0';
|
|
|
|
}
|
2023-11-12 19:34:40 +09:00
|
|
|
}
|
|
|
|
|
2023-11-14 18:39:41 +09:00
|
|
|
int ut_random_player(char *player) {
|
|
|
|
int random = open("/dev/urandom", O_RDONLY);
|
|
|
|
if (read(random, player, 1) < 0) {return errno;}
|
|
|
|
*player = *player % 2 == 0 ? 'X' : 'O';
|
2023-11-15 11:47:05 +09:00
|
|
|
*player = 'X'; // testing
|
2023-11-14 18:39:41 +09:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2023-11-12 19:34:40 +09:00
|
|
|
#define T(r, c) (tiles[offset + stride * r + c])
|
2023-11-13 00:53:57 +09:00
|
|
|
char ut_winner(const char *tiles, int offset, int stride) {
|
2023-11-12 19:34:40 +09:00
|
|
|
|
2023-11-12 19:57:13 +09:00
|
|
|
// 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);
|
2023-11-12 20:43:33 +09:00
|
|
|
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;}
|
2023-11-12 20:39:43 +09:00
|
|
|
}
|
|
|
|
|
2023-11-12 20:43:33 +09:00
|
|
|
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
|
2023-11-12 19:34:40 +09:00
|
|
|
}
|
|
|
|
|
2023-11-12 19:57:13 +09:00
|
|
|
int ut_move(struct ut_state *new_state, const struct ut_state *old_state, int row, int col)
|
2023-11-12 19:34:40 +09:00
|
|
|
{
|
2023-11-12 19:57:13 +09:00
|
|
|
// bad move - out of bounds
|
|
|
|
if(row < 0 || row >= 9 || col < 0 || col >= 9) {return 1;}
|
2023-11-12 19:34:40 +09:00
|
|
|
|
2023-11-12 19:57:13 +09:00
|
|
|
// 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;}
|
2023-11-12 19:34:40 +09:00
|
|
|
|
2023-11-12 19:57:13 +09:00
|
|
|
// bad move - tile is occupied
|
2023-11-13 12:02:03 +09:00
|
|
|
if(old_state->tiles[row][col] != '\0') {return 1;}
|
2023-11-12 19:34:40 +09:00
|
|
|
|
2023-11-13 12:02:03 +09:00
|
|
|
// bad move - board is finished
|
|
|
|
if(old_state->boards[row / 3][col / 3] != '\0') {return 1;}
|
2023-11-13 19:22:19 +09:00
|
|
|
|
2023-11-12 19:57:13 +09:00
|
|
|
// 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));
|
2023-11-12 19:34:40 +09:00
|
|
|
|
2023-11-12 19:57:13 +09:00
|
|
|
// do move
|
|
|
|
new_state->tiles[row][col] = old_state->player;
|
2023-11-12 20:58:58 +09:00
|
|
|
new_state->boards[row / 3][col / 3] = ut_winner((char *)new_state->tiles, 27 * (row / 3) + 3 * (col / 3), 9);
|
2023-11-12 19:57:13 +09:00
|
|
|
|
|
|
|
// 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;
|
2023-11-12 19:34:40 +09:00
|
|
|
|
2023-11-12 19:57:13 +09:00
|
|
|
new_state->player = ut_turn(old_state->player);
|
|
|
|
return 0;
|
2023-11-12 19:34:40 +09:00
|
|
|
}
|
|
|
|
|
2023-11-15 13:07:38 +09:00
|
|
|
// TODO highlight last placed
|
|
|
|
void ut_drawBoard(void (*mvch)(void*, int, int, char), void *arg, const char *tiles, int offset, int stride, int iy, int ix, char winner, bool highlight)
|
2023-11-13 00:53:57 +09:00
|
|
|
{
|
2023-11-15 13:07:38 +09:00
|
|
|
// 7x7 board display
|
2023-11-13 00:53:57 +09:00
|
|
|
/*
|
|
|
|
* X|X|X
|
|
|
|
* -+-+-
|
|
|
|
* X|X|X
|
|
|
|
* -+-+-
|
|
|
|
* X|X|X
|
|
|
|
*/
|
2023-11-15 13:07:38 +09:00
|
|
|
for(int r = 0; r < 3; r++) // tiles
|
2023-11-13 00:53:57 +09:00
|
|
|
for(int c = 0; c < 3; c++)
|
2023-11-15 13:07:38 +09:00
|
|
|
mvch(arg, iy + 2 * r, ix + 2 * c, T(r, c) != '\0' ? T(r, c) : ' ');
|
2023-11-13 00:53:57 +09:00
|
|
|
//char info = winner != '\0' ? winner : highlight ? '*' : ' ';
|
2023-11-15 13:07:38 +09:00
|
|
|
for(int r = 0; r < 3; r++) // |
|
2023-11-13 00:53:57 +09:00
|
|
|
for(int c = 0; c < 2; c++)
|
2023-11-15 13:07:38 +09:00
|
|
|
mvch(arg, iy + 2 * r, ix + 2 * c + 1, winner != '\0' ? winner : '|');
|
|
|
|
for(int r = 0; r < 2; r++) // -
|
2023-11-13 00:53:57 +09:00
|
|
|
for(int c = 0; c < 3; c++)
|
2023-11-15 13:07:38 +09:00
|
|
|
mvch(arg, iy + 2 * r + 1, ix + 2 * c, winner != '\0' ? winner : '-');
|
|
|
|
for(int r = 0; r < 2; r++) // +
|
|
|
|
for(int c = 0; c < 2; c++)
|
|
|
|
mvch(arg, iy + 2 * r + 1, ix + 2 * c + 1, winner != '\0' ? winner : highlight ? '*' : '+');
|
|
|
|
for(int r = 0; r < 7; r++) // | boundary
|
2023-11-13 00:53:57 +09:00
|
|
|
for(int c = 0; c < 2; c++)
|
2023-11-15 13:07:38 +09:00
|
|
|
mvch(arg, iy + r, ix + 6 * c, ' ');
|
|
|
|
for(int r = 0; r < 2; r++) // - boundary
|
|
|
|
for(int c = 0; c < 7; c++)
|
|
|
|
mvch(arg, iy + 6 * r, ix + c, ' ');
|
2023-11-13 00:53:57 +09:00
|
|
|
}
|
2023-11-15 13:07:38 +09:00
|
|
|
void ut_drawTiles(void (*mvch)(void*, int, int, char), void *arg, const struct ut_state *state)
|
2023-11-13 00:53:57 +09:00
|
|
|
{
|
|
|
|
for(int r = 0; r < 3; r++)
|
|
|
|
for(int c = 0; c < 3; c++)
|
2023-11-15 13:07:38 +09:00
|
|
|
ut_drawBoard(mvch, arg, (char *)state->tiles,
|
|
|
|
27 * r + 3 * c, 9,
|
|
|
|
7 * r + 1, 7 * c + 1,
|
|
|
|
state->boards[r][c],
|
|
|
|
state->playBoard == -1 || state->playBoard == 3 * r + c);
|
|
|
|
}
|
|
|
|
void ut_drawBoards(void (*mvch)(void*, int, int, char), void *arg, const struct ut_state *state)
|
|
|
|
{
|
|
|
|
ut_drawBoard(mvch, arg, (char *)state->boards,
|
|
|
|
0, 3,
|
|
|
|
0, 0,
|
|
|
|
'\0', false);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ut_cursmvch(void *arg, int y, int x, char c)
|
|
|
|
{
|
|
|
|
mvaddch(/*curs_line + */y, x, c);
|
|
|
|
}
|
|
|
|
#define DTILES_Y 21
|
|
|
|
#define DTILES_X 21
|
|
|
|
void ut_tmvch(void *arg, int y, int x, char c)
|
|
|
|
{
|
|
|
|
((char (*)[DTILES_X])arg)[y][x] = c;
|
2023-11-13 00:53:57 +09:00
|
|
|
}
|
2023-11-15 13:07:38 +09:00
|
|
|
#define DBOARDS_Y 7
|
|
|
|
#define DBOARDS_X 7
|
|
|
|
void ut_bmvch(void *arg, int y, int x, char c)
|
|
|
|
{
|
|
|
|
((char (*)[DBOARDS_X])arg)[y][x] = c;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ut_cursdraw(const struct ut_state *state)
|
|
|
|
{
|
|
|
|
ut_cursprintf(fd, "Turn: %c Play board: %d\n", (int)state->player, state->playBoard);
|
|
|
|
ut_drawTiles(ut_cursmvch, NULL, state);
|
|
|
|
//ut_drawBoards(ut_cursmvch, NULL, state);
|
|
|
|
|
|
|
|
}
|
|
|
|
void ut_sockdraw(const struct ut_state *state, int fd)
|
|
|
|
{
|
|
|
|
ut_dprintf(fd, "| Turn: %c Play board: %d\n", (int)state->player, state->playBoard);
|
|
|
|
char dtiles[DTILES_Y][DTILES_X];
|
|
|
|
ut_drawTiles(ut_tmvch, dtiles, state);
|
|
|
|
for(int r = 0; r < DTILES_Y; r++)
|
|
|
|
{
|
|
|
|
ut_dprintf(fd, "| %.*s\n", DTILES_X, dtiles[r]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-11-13 00:53:57 +09:00
|
|
|
|
2023-11-13 11:52:21 +09:00
|
|
|
int ut_click(const struct ut_state *state, int *r, int *c)
|
2023-11-13 00:53:57 +09:00
|
|
|
{
|
2023-11-13 11:52:21 +09:00
|
|
|
#define P(r, c, d) ((state->playBoard == -1 || state->playBoard == 3 * (r / 3) + (c / 3)) && \
|
2023-11-13 21:51:48 +09:00
|
|
|
(state->boards[r / 3][c / 3] == '\0' || d % 3 == 1))
|
2023-11-13 00:53:57 +09:00
|
|
|
MEVENT event;
|
2023-11-13 11:52:21 +09:00
|
|
|
mvaddstr(21, 0, "Select move with arrow keys or mouse.");
|
|
|
|
if(state->playBoard == -1)
|
|
|
|
{
|
|
|
|
*r = 3 * (*r / 3) + 1;
|
|
|
|
*c = 3 * (*c / 3) + 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
*r = 3 * (state->playBoard / 3) + 1;
|
|
|
|
*c = 3 * (state->playBoard % 3) + 1;
|
|
|
|
}
|
2023-11-13 00:53:57 +09:00
|
|
|
for(;;)
|
|
|
|
{
|
2023-11-13 11:52:21 +09:00
|
|
|
/*if(state->boards[*r / 3][*c / 3] != '\0')
|
|
|
|
{
|
|
|
|
*r = 3 * (*r / 3) + 1;
|
|
|
|
*c = 3 * (*c / 3) + 1;
|
|
|
|
}*/
|
2023-11-13 00:53:57 +09:00
|
|
|
move((7 * (*r / 3) + 1) + (2 * (*r % 3)),
|
|
|
|
(7 * (*c / 3) + 1) + (2 * (*c % 3)));
|
|
|
|
refresh();
|
|
|
|
switch(getch())
|
|
|
|
{
|
|
|
|
case KEY_MOUSE:
|
|
|
|
if(getmouse(&event) == OK && (event.bstate & BUTTON1_CLICKED))
|
|
|
|
{
|
|
|
|
if(event.y < 0 || event.y >= 21) {break;}
|
|
|
|
if(event.x < 0 || event.x >= 21) {break;}
|
2023-11-13 12:02:03 +09:00
|
|
|
*r = (event.y % 7 - 1) / 2 + 3 * (event.y / 7);
|
|
|
|
*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;}
|
2023-11-13 00:53:57 +09:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
break;
|
2023-11-13 11:52:21 +09:00
|
|
|
case 'k': /* FALLTHROUGH */
|
2023-11-13 00:53:57 +09:00
|
|
|
case 'w': /* FALLTHROUGH */
|
|
|
|
case KEY_UP:
|
2023-11-13 11:52:21 +09:00
|
|
|
//*r = (((*r - 1) % 9) + 9) % 9;
|
|
|
|
for(int i = 0; i < 9 + 1; i++)
|
|
|
|
{
|
|
|
|
*r = (*r + 9 - 1) % 9;
|
|
|
|
if(P(*r, *c, *r)) {break;}
|
|
|
|
}
|
2023-11-13 00:53:57 +09:00
|
|
|
break;
|
2023-11-13 11:52:21 +09:00
|
|
|
case 'h': /* FALLTHROUGH */
|
2023-11-13 00:53:57 +09:00
|
|
|
case 'a': /* FALLTHROUGH */
|
|
|
|
case KEY_LEFT:
|
2023-11-13 11:52:21 +09:00
|
|
|
//*c = (((*c - 1) % 9) + 9) % 9;
|
|
|
|
for(int i = 0; i < 9 + 1; i++)
|
|
|
|
{
|
|
|
|
*c = (*c + 9 - 1) % 9;
|
|
|
|
if(P(*r, *c, *c)) {break;}
|
|
|
|
}
|
2023-11-13 00:53:57 +09:00
|
|
|
break;
|
2023-11-13 11:52:21 +09:00
|
|
|
case 'j': /* FALLTHROUGH */
|
2023-11-13 00:53:57 +09:00
|
|
|
case 's': /* FALLTHROUGH */
|
|
|
|
case KEY_DOWN:
|
2023-11-13 11:52:21 +09:00
|
|
|
//*r = (*r + 1) % 9;
|
|
|
|
for(int i = 0; i < 9 + 1; i++)
|
|
|
|
{
|
|
|
|
*r = (*r + 1) % 9;
|
|
|
|
if(P(*r, *c, *r)) {break;}
|
|
|
|
}
|
2023-11-13 00:53:57 +09:00
|
|
|
break;
|
2023-11-13 11:52:21 +09:00
|
|
|
case 'l': /* FALLTHROUGH */
|
2023-11-13 00:53:57 +09:00
|
|
|
case 'd': /* FALLTHROUGH */
|
|
|
|
case KEY_RIGHT:
|
2023-11-13 11:52:21 +09:00
|
|
|
//*c = (*c + 1) % 9;
|
|
|
|
for(int i = 0; i < 9 + 1; i++)
|
|
|
|
{
|
|
|
|
*c = (*c + 1) % 9;
|
|
|
|
if(P(*r, *c, *c)) {break;}
|
|
|
|
}
|
2023-11-13 00:53:57 +09:00
|
|
|
break;
|
|
|
|
case ' ': /* FALLTHROUGH */
|
2023-11-13 11:52:21 +09:00
|
|
|
case '\r': /* FALLTHROUGH */
|
2023-11-13 00:53:57 +09:00
|
|
|
case KEY_ENTER:
|
|
|
|
return 0;
|
2023-11-13 14:01:26 +09:00
|
|
|
case ERR: /* FALLTHROUGH */
|
2023-11-13 00:53:57 +09:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2023-11-13 11:52:21 +09:00
|
|
|
#undef P
|
2023-11-13 00:53:57 +09:00
|
|
|
}
|
|
|
|
|
2023-11-15 13:07:38 +09:00
|
|
|
int curs_line; // set this to 21 and reset it on erase TODO - use this as an offset rather
|
|
|
|
void ut_cursprint(const char *str, int n)
|
2023-11-13 22:50:02 +09:00
|
|
|
{
|
|
|
|
mvaddnstr(info_line, 0, str, n);
|
|
|
|
// info_line++; // depends on str not containing newlines
|
|
|
|
int y, x;
|
|
|
|
getyx(stdscr, y, x);
|
|
|
|
info_line = y + 1;
|
|
|
|
}
|
|
|
|
|
2023-11-13 23:09:40 +09:00
|
|
|
int ut_readfill(int fd, char *x, size_t l)
|
2023-11-13 22:50:02 +09:00
|
|
|
{
|
|
|
|
while(l > 0)
|
|
|
|
{
|
|
|
|
int r = read(fd, x, l);
|
|
|
|
if(r < 0)
|
|
|
|
{
|
|
|
|
if(errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) {continue;}
|
|
|
|
else {return 1;}
|
|
|
|
}
|
|
|
|
else if(r == 0) {return 2;}
|
|
|
|
x += r; l -= r;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2023-11-13 23:09:40 +09:00
|
|
|
int ut_writefill(int fd, const char *x, size_t l)
|
|
|
|
{
|
|
|
|
while(l > 0)
|
|
|
|
{
|
|
|
|
int r = write(fd, x, l);
|
|
|
|
if(r < 0)
|
|
|
|
{
|
|
|
|
if(errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) {continue;}
|
|
|
|
else {return 1;}
|
|
|
|
}
|
|
|
|
x += r; l -= r;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2023-11-13 22:50:02 +09:00
|
|
|
|
2023-11-14 23:10:49 +09:00
|
|
|
int ut_socket_buffer_size(struct ut_socket_buffer *sockbuf) {
|
|
|
|
int size = sockbuf->stop - sockbuf->start;
|
|
|
|
if (size < 0) {size += sockbuf->len;}
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Copies up to (and including) first '\n' in socket buffer, otherwise whole buffer */
|
|
|
|
int ut_readline_buffer(struct ut_socket_buffer *sockbuf, char *line, size_t len) {
|
|
|
|
int size = ut_socket_buffer_size(sockbuf);
|
2023-11-15 11:47:05 +09:00
|
|
|
printf("sockbuf size: %d\n", size);
|
2023-11-15 11:46:07 +09:00
|
|
|
for (int i = 0; i < size; i++) {
|
|
|
|
if (i > len) {return -2;}
|
|
|
|
line[i] = sockbuf->buf[(sockbuf->start + i) % sockbuf->len];
|
|
|
|
if (line[i] == '\n') {
|
2023-11-14 23:10:49 +09:00
|
|
|
sockbuf->start = (sockbuf->start + i + 1) % sockbuf->len;
|
2023-11-15 11:47:05 +09:00
|
|
|
printf("new start: %d\n", sockbuf->start);
|
2023-11-14 23:10:49 +09:00
|
|
|
return i + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sockbuf->start = (sockbuf->start + size) % sockbuf->len;
|
2023-11-15 11:47:05 +09:00
|
|
|
printf("new start from size: %d\n", sockbuf->start);
|
2023-11-14 23:10:49 +09:00
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ut_readline_socket(struct ut_socket_buffer *sockbuf, char *line, size_t len) {
|
|
|
|
while (len > 0) {
|
|
|
|
int r = read(sockbuf->fd, line, len);
|
2023-11-15 11:47:05 +09:00
|
|
|
line[r] = 0;
|
|
|
|
printf("read %d from fd %d\n", r, sockbuf->fd);
|
|
|
|
printf(">>socket data: '%s'\n", line);
|
2023-11-14 23:10:49 +09:00
|
|
|
if (r < 0) {
|
|
|
|
if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) {continue;}
|
2023-11-15 11:46:07 +09:00
|
|
|
else {return -1;}
|
2023-11-14 23:10:49 +09:00
|
|
|
}
|
2023-11-15 11:46:07 +09:00
|
|
|
else if (r == 0) {return -1;}
|
2023-11-14 23:10:49 +09:00
|
|
|
for (int i = 0; i < r; i++) {
|
|
|
|
if (line[i] == '\n') {
|
|
|
|
int size = ut_socket_buffer_size(sockbuf);
|
2023-11-15 11:46:07 +09:00
|
|
|
if (r - (i + 1) >= sockbuf->len - size) {return -2;}
|
|
|
|
for (int j = 0; j < r - (i + 1); j++) {
|
|
|
|
sockbuf->buf[(sockbuf->stop + j) % sockbuf->len] = line[i + 1 + j];
|
2023-11-14 23:10:49 +09:00
|
|
|
}
|
2023-11-15 11:46:07 +09:00
|
|
|
sockbuf->stop = (sockbuf->stop + r - (i + 1)) % sockbuf->len;
|
2023-11-14 23:10:49 +09:00
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
line += r;
|
|
|
|
len -= r;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int ut_readline(struct ut_socket_buffer *sockbuf, char *line, size_t len) {
|
|
|
|
int nb = ut_readline_buffer(sockbuf, line, len);
|
|
|
|
if (nb < 0) {return nb;}
|
2023-11-15 11:47:05 +09:00
|
|
|
line[nb] = 0;
|
|
|
|
printf("got partial line from buffer %d bytes: '%s'\n", nb, line);
|
|
|
|
if (nb >= 1 && line[nb - 1] == '\n') {return nb - 1;}
|
2023-11-14 23:10:49 +09:00
|
|
|
int ns = ut_readline_socket(sockbuf, line + nb, len - nb);
|
|
|
|
if (ns < 0) {return ns;}
|
2023-11-15 11:47:05 +09:00
|
|
|
line[nb+ns] = 0;
|
|
|
|
printf("got end of line from socket %d bytes: '%s'\n", ns, line+nb);
|
2023-11-14 23:10:49 +09:00
|
|
|
return nb + ns;
|
|
|
|
}
|
|
|
|
|
2023-11-13 22:50:02 +09:00
|
|
|
#define MAX_LINE 128
|
|
|
|
|
|
|
|
int ut_dprintf(int fd, const char *restrict format, ...)
|
|
|
|
{
|
|
|
|
char line[MAX_LINE];
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
int n = vsnprintf(line, MAX_LINE, format, ap);
|
|
|
|
va_end(ap);
|
|
|
|
if(n < 0 || n > MAX_LINE - 1) {return -1;}
|
2023-11-13 23:09:40 +09:00
|
|
|
if(ut_writefill(fd, line, n)) {return -1;}
|
2023-11-13 22:50:02 +09:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
int ut_cursprintf(const char *restrict format, ...)
|
|
|
|
{
|
|
|
|
char line[MAX_LINE];
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
int n = vsnprintf(line, MAX_LINE, format, ap);
|
|
|
|
va_end(ap);
|
|
|
|
if(n < 0 || n > MAX_LINE - 1) {return -1;}
|
2023-11-15 13:07:38 +09:00
|
|
|
ut_cursprint(line, n);
|
2023-11-13 22:50:02 +09:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2023-11-13 23:09:40 +09:00
|
|
|
void ut_show(const struct ut_state *state, int fd, bool as_comment) {
|
2023-11-13 19:32:07 +09:00
|
|
|
#define tiles state->tiles
|
2023-11-14 18:39:41 +09:00
|
|
|
ut_dprintf(fd, "%sTurn: %c\n%sPlay board: %d\n", as_comment ? "| " : "", (int)state->player, as_comment ? "| " : "", state->playBoard);
|
2023-11-12 19:34:40 +09:00
|
|
|
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;
|
|
|
|
}
|
2023-11-13 23:09:40 +09:00
|
|
|
ut_dprintf(fd, "%s 012 345 678\n", as_comment ? "| " : "");
|
2023-11-13 19:32:07 +09:00
|
|
|
for(int y = 0; y < 9; y++)
|
|
|
|
{
|
2023-11-12 19:34:40 +09:00
|
|
|
if (y == 3 || y == 6) {
|
2023-11-13 23:09:40 +09:00
|
|
|
ut_dprintf(fd, "%s ---+---+---\n", as_comment ? "| " : "");
|
2023-11-12 19:34:40 +09:00
|
|
|
}
|
2023-11-13 23:09:40 +09:00
|
|
|
ut_dprintf(fd, "%s%d ", as_comment ? "| " : "", y);
|
2023-11-13 19:32:07 +09:00
|
|
|
for(int x = 0; x < 9; x++)
|
|
|
|
{
|
2023-11-12 19:34:40 +09:00
|
|
|
if (x == 3 || x == 6) {
|
2023-11-13 23:09:40 +09:00
|
|
|
ut_writefill(fd, "|", 1);
|
2023-11-12 19:34:40 +09:00
|
|
|
}
|
2023-11-13 23:09:40 +09:00
|
|
|
ut_writefill(fd, tiles[y][x] ? &tiles[y][x] : " ", 1);
|
2023-11-13 19:32:07 +09:00
|
|
|
}
|
2023-11-12 21:05:57 +09:00
|
|
|
if (y / 3 == play_board_row || play_board_row == -1) {
|
2023-11-13 23:09:40 +09:00
|
|
|
ut_writefill(fd, "<", 1);
|
2023-11-12 19:34:40 +09:00
|
|
|
}
|
2023-11-13 23:09:40 +09:00
|
|
|
ut_writefill(fd, "\n", 1);
|
2023-11-13 19:32:07 +09:00
|
|
|
}
|
2023-11-12 21:05:57 +09:00
|
|
|
if (play_board_col == -1) {
|
2023-11-13 23:09:40 +09:00
|
|
|
ut_dprintf(fd, "%s ^^^ ^^^ ^^^", as_comment ? "| " : "");
|
2023-11-12 21:05:57 +09:00
|
|
|
} else {
|
2023-11-13 23:09:40 +09:00
|
|
|
ut_dprintf(fd, "%s ", as_comment ? "| " : "");
|
2023-11-12 19:34:40 +09:00
|
|
|
for (int i = 0; i < play_board_col; i++) {
|
2023-11-13 23:09:40 +09:00
|
|
|
ut_dprintf(fd, " ");
|
2023-11-12 19:34:40 +09:00
|
|
|
}
|
2023-11-13 23:09:40 +09:00
|
|
|
ut_dprintf(fd, "^^^");
|
2023-11-12 19:34:40 +09:00
|
|
|
}
|
2023-11-13 23:09:40 +09:00
|
|
|
ut_writefill(fd, "\n", 1);
|
2023-11-13 19:32:07 +09:00
|
|
|
#undef tiles
|
2023-11-12 19:34:40 +09:00
|
|
|
}
|
|
|
|
|
2023-11-13 00:05:26 +09:00
|
|
|
void ut_show_boards(const struct ut_state *state) {
|
|
|
|
for (int j = 0; j < 3; j++) {
|
|
|
|
for (int i = 0; i < 3; i++) {
|
2023-11-13 19:29:13 +09:00
|
|
|
putchar(state->boards[j][i] ? state->boards[j][i] : ' ');
|
2023-11-13 00:05:26 +09:00
|
|
|
}
|
|
|
|
putchar('\n');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-11-12 19:57:13 +09:00
|
|
|
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;
|
2023-11-12 20:24:27 +09:00
|
|
|
break;
|
2023-11-12 19:57:13 +09:00
|
|
|
}
|
|
|
|
return true;
|
2023-11-12 19:34:40 +09:00
|
|
|
}
|
|
|
|
|
2023-11-15 11:47:05 +09:00
|
|
|
int getpos_net(const struct ut_state *state, struct ut_socket_buffer *sockbuf, int *x, int *y) { // TODO
|
|
|
|
const int MAX_LINE_LEN = 128;
|
2023-11-13 20:55:12 +09:00
|
|
|
char byte;
|
|
|
|
int n;
|
|
|
|
while (true) {
|
2023-11-15 11:47:05 +09:00
|
|
|
char line[MAX_LINE_LEN];
|
|
|
|
int len = ut_readline(sockbuf, line, MAX_LINE_LEN);
|
|
|
|
if (len < 0) {return len;}
|
|
|
|
if (len == 0) {printf("sex\n");return -1;}
|
|
|
|
line[len] = 0;
|
|
|
|
printf("got >>>>>> line: '%s'\n", line);
|
|
|
|
if (line[0] == '|') {continue;}
|
|
|
|
if (len != 3) {return -3;}
|
|
|
|
if (line[1] != ',') {return -3;}
|
|
|
|
*x = line[0] - 0x30;
|
|
|
|
*y = line[2] - 0x30;
|
|
|
|
break;
|
2023-11-13 00:42:24 +09:00
|
|
|
}
|
2023-11-13 20:55:12 +09:00
|
|
|
printf("x=%d y=%d\n", *x, *y);
|
2023-11-15 11:47:05 +09:00
|
|
|
return 0;
|
2023-11-13 20:55:12 +09:00
|
|
|
|
2023-11-13 00:05:26 +09:00
|
|
|
}
|
|
|
|
|
2023-11-12 20:43:33 +09:00
|
|
|
void finish(int sig)
|
|
|
|
{
|
2023-11-13 21:51:48 +09:00
|
|
|
// putchar('\n');
|
2023-11-12 20:43:33 +09:00
|
|
|
endwin();
|
|
|
|
// other cleanup
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
|
2023-11-13 21:51:48 +09:00
|
|
|
/*int main(int argc, char *argv[]) {
|
2023-11-12 20:43:33 +09:00
|
|
|
signal(SIGINT, finish);
|
2023-11-12 21:20:31 +09:00
|
|
|
initscr();
|
|
|
|
keypad(stdscr, TRUE);
|
2023-11-13 11:52:21 +09:00
|
|
|
nonl(); // \r instead of \r\n
|
2023-11-12 21:20:31 +09:00
|
|
|
cbreak();
|
|
|
|
noecho();
|
2023-11-13 00:53:57 +09:00
|
|
|
mousemask(BUTTON1_CLICKED, NULL);
|
2023-11-12 20:43:33 +09:00
|
|
|
|
|
|
|
struct ut_state state = ut_initial;
|
2023-11-12 19:57:13 +09:00
|
|
|
while (true) {
|
2023-11-13 00:53:57 +09:00
|
|
|
int r, c, err;
|
2023-11-13 11:52:21 +09:00
|
|
|
erase();
|
2023-11-13 00:53:57 +09:00
|
|
|
ut_draw(&state);
|
2023-11-12 19:57:13 +09:00
|
|
|
char w = ut_winner((char *)state.boards, 0, 3);
|
|
|
|
if(w)
|
|
|
|
{
|
2023-11-12 20:43:33 +09:00
|
|
|
if(w == ' ')
|
|
|
|
{
|
2023-11-13 11:52:21 +09:00
|
|
|
mvaddstr(21, 0, "Draw!");
|
2023-11-12 20:43:33 +09:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2023-11-13 11:52:21 +09:00
|
|
|
mvaddch(21, 0, w);
|
|
|
|
mvaddstr(21, 1, " Wins!");
|
2023-11-12 20:43:33 +09:00
|
|
|
}
|
2023-11-13 11:52:21 +09:00
|
|
|
mvaddstr(22, 0, "Press any key to exit.");
|
2023-11-13 00:53:57 +09:00
|
|
|
refresh();
|
|
|
|
mousemask(0, NULL);
|
|
|
|
getch();
|
|
|
|
break;
|
2023-11-12 19:57:13 +09:00
|
|
|
}
|
2023-11-13 11:52:21 +09:00
|
|
|
err = ut_click(&state, &r, &c);
|
|
|
|
if (err) {continue;}
|
|
|
|
err = ut_move(&state, &state, r, c);
|
|
|
|
if (err) {continue;}
|
2023-11-12 19:57:13 +09:00
|
|
|
}
|
2023-11-13 00:53:57 +09:00
|
|
|
finish(0);
|
2023-11-12 19:57:13 +09:00
|
|
|
return 0;
|
2023-11-13 21:51:48 +09:00
|
|
|
}*/
|
|
|
|
|
2023-11-14 18:39:41 +09:00
|
|
|
int ut_local_game(struct ut_state *state) { // TODO replace with from ncurses main
|
2023-11-13 00:05:26 +09:00
|
|
|
int x, y;
|
2023-11-12 19:57:13 +09:00
|
|
|
while (true) {
|
2023-11-14 18:39:41 +09:00
|
|
|
ut_show(state, 1, false);
|
2023-11-13 00:05:26 +09:00
|
|
|
ut_show_boards(state);
|
|
|
|
bool ok = getpos(state, &x, &y);
|
2023-11-12 19:57:13 +09:00
|
|
|
if (!ok) {continue;}
|
2023-11-13 21:19:29 +09:00
|
|
|
int err = ut_move(state, state, y, x);
|
2023-11-12 19:57:13 +09:00
|
|
|
if (err) {continue;}
|
2023-11-12 22:31:24 +09:00
|
|
|
char w = ut_winner((char *)state->boards, 0, 3);
|
2023-11-12 19:57:13 +09:00
|
|
|
if(w)
|
|
|
|
{
|
2023-11-12 20:43:33 +09:00
|
|
|
if(w == ' ')
|
|
|
|
{
|
|
|
|
printf("\nDraw!\n");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
printf("\n%c wins!\n", (int)w);
|
|
|
|
}
|
2023-11-14 18:39:41 +09:00
|
|
|
break;
|
2023-11-12 19:57:13 +09:00
|
|
|
}
|
|
|
|
}
|
2023-11-14 18:39:41 +09:00
|
|
|
return 0;
|
2023-11-12 22:31:24 +09:00
|
|
|
}
|
|
|
|
|
2023-11-15 11:47:05 +09:00
|
|
|
int ut_network_game(struct ut_state *state, struct ut_socket_buffer *sockbuf, char player) { // TODO
|
2023-11-13 00:05:26 +09:00
|
|
|
int x, y;
|
2023-11-14 18:39:41 +09:00
|
|
|
bool host = player == state->host_player;
|
2023-11-13 21:37:05 +09:00
|
|
|
printf("You play as %c.\n", player);
|
2023-11-13 00:05:26 +09:00
|
|
|
while (true) {
|
2023-11-14 18:39:41 +09:00
|
|
|
ut_show(state, 1, false);
|
2023-11-13 00:05:26 +09:00
|
|
|
ut_show_boards(state);
|
2023-11-15 11:47:05 +09:00
|
|
|
ut_show(state, sockbuf->fd, true);
|
2023-11-13 21:37:05 +09:00
|
|
|
if (state->player == player) {
|
2023-11-15 11:47:05 +09:00
|
|
|
if (host) {ut_dprintf(sockbuf->fd, "| Waiting for game partner ...\n");}
|
2023-11-13 00:05:26 +09:00
|
|
|
bool ok = getpos(state, &x, &y);
|
|
|
|
if (!ok) {continue;}
|
2023-11-15 11:47:05 +09:00
|
|
|
ut_dprintf(sockbuf->fd, "%d,%d\n", x, y);
|
2023-11-13 00:05:26 +09:00
|
|
|
} else {
|
2023-11-13 19:32:07 +09:00
|
|
|
printf("Waiting for game partner ...\n");
|
2023-11-14 18:39:41 +09:00
|
|
|
if (host) {
|
2023-11-15 11:47:05 +09:00
|
|
|
ut_dprintf(sockbuf->fd, "|\n"); // aligns game board each turn
|
|
|
|
ut_dprintf(sockbuf->fd, "| Place token %c in position x,y: ", ut_turn(player));
|
|
|
|
}
|
|
|
|
int err = getpos_net(state, sockbuf, &x, &y);
|
|
|
|
if (err == -1) {
|
|
|
|
printf("Connection closed.\n");
|
|
|
|
return 1;
|
|
|
|
} else if (err == -2) {
|
|
|
|
printf("Partner sent too much data - exiting\n");
|
|
|
|
return 1;
|
|
|
|
} else if (err == -3) {
|
|
|
|
printf("Partner sent malformed data - retrying ...\n");
|
|
|
|
continue;
|
2023-11-14 18:39:41 +09:00
|
|
|
}
|
2023-11-13 00:05:26 +09:00
|
|
|
}
|
2023-11-13 19:32:07 +09:00
|
|
|
int err = ut_move(state, state, y, x);
|
2023-11-13 00:42:24 +09:00
|
|
|
if (err) {continue;}
|
2023-11-15 11:47:05 +09:00
|
|
|
ut_dprintf(sockbuf->fd, "|\n");
|
2023-11-13 00:05:26 +09:00
|
|
|
char w = ut_winner((char *)state->boards, 0, 3);
|
|
|
|
if(w)
|
|
|
|
{
|
|
|
|
if(w == ' ')
|
|
|
|
{
|
|
|
|
printf("\nDraw!\n");
|
2023-11-15 11:47:05 +09:00
|
|
|
if (host) {ut_dprintf(sockbuf->fd, "|\n|Draw!\n");}
|
2023-11-15 11:49:30 +09:00
|
|
|
close(sockbuf->fd);
|
2023-11-13 00:05:26 +09:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
printf("\n%c wins!\n", (int)w);
|
2023-11-15 11:47:05 +09:00
|
|
|
if (host) {ut_dprintf(sockbuf->fd, "|\n|%c wins!\n", (int)w);}
|
2023-11-15 11:49:30 +09:00
|
|
|
close(sockbuf->fd);
|
2023-11-13 00:05:26 +09:00
|
|
|
}
|
2023-11-14 19:16:03 +09:00
|
|
|
break;
|
2023-11-13 00:05:26 +09:00
|
|
|
}
|
|
|
|
}
|
2023-11-14 19:16:03 +09:00
|
|
|
return 0;
|
2023-11-12 22:31:24 +09:00
|
|
|
}
|
|
|
|
|
2023-11-14 18:39:41 +09:00
|
|
|
int ut_host_game(struct ut_state *state) {
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
// decide X or O
|
|
|
|
if (ut_random_player(&state->host_player) != 0) {return 1;}
|
|
|
|
|
|
|
|
// tell partner X or O
|
|
|
|
ut_dprintf(conn, "%c\n", ut_turn(state->host_player)); // TODO
|
|
|
|
|
2023-11-15 11:47:05 +09:00
|
|
|
struct ut_socket_buffer connbuf = {
|
|
|
|
.fd = conn,
|
|
|
|
.buf = (char[128]){0},
|
|
|
|
.len = 128,
|
|
|
|
.start = 0,
|
|
|
|
.stop = 0,
|
|
|
|
};
|
|
|
|
return ut_network_game(state, &connbuf, state->host_player);
|
2023-11-14 18:39:41 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
int ut_join_game(struct ut_state *state) {
|
|
|
|
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) },
|
|
|
|
};
|
|
|
|
printf("Connecting to game host at 127.0.0.1:6669 ...\n");
|
|
|
|
connect(sock, (struct sockaddr*)&addr, sizeof(addr));
|
|
|
|
|
|
|
|
// host decides X or O
|
2023-11-15 11:47:05 +09:00
|
|
|
char player_buf[2];
|
|
|
|
char *player = (char*)&player_buf;
|
|
|
|
int r = ut_readfill(sock, player_buf, 2);
|
2023-11-14 18:39:41 +09:00
|
|
|
if (r == 2) {printf("Connection closed.\n");}
|
|
|
|
if (r != 0) {return 1;}
|
2023-11-15 11:47:05 +09:00
|
|
|
state->host_player = ut_turn(*player);
|
|
|
|
|
|
|
|
struct ut_socket_buffer sockbuf = {
|
|
|
|
.fd = sock,
|
|
|
|
.buf = (char[128]){0},
|
|
|
|
.len = 128,
|
|
|
|
.start = 0,
|
|
|
|
.stop = 0,
|
|
|
|
};
|
|
|
|
return ut_network_game(state, &sockbuf, *player);
|
2023-11-14 18:39:41 +09:00
|
|
|
}
|
|
|
|
|
2023-11-12 22:31:24 +09:00
|
|
|
int main(int argc, char **argv) {
|
|
|
|
signal(SIGINT, finish);
|
|
|
|
struct ut_state state = ut_initial;
|
2023-11-14 18:39:41 +09:00
|
|
|
if (argc != 2) {
|
|
|
|
printf(HELP_TEXT);
|
|
|
|
return 1;
|
|
|
|
} else if (strncmp(argv[1], arg_local, strlen(arg_local)) == 0) {
|
|
|
|
return ut_local_game(&state);
|
2023-11-12 22:31:24 +09:00
|
|
|
} else if (strncmp(argv[1], arg_host, strlen(arg_host)) == 0) {
|
2023-11-14 18:39:41 +09:00
|
|
|
return ut_host_game(&state);
|
2023-11-12 22:31:24 +09:00
|
|
|
} else if (strncmp(argv[1], arg_join, strlen(arg_join)) == 0) {
|
2023-11-14 18:39:41 +09:00
|
|
|
return ut_join_game(&state);
|
2023-11-12 22:31:24 +09:00
|
|
|
} else {
|
2023-11-14 18:39:41 +09:00
|
|
|
printf(HELP_TEXT, argv[1]);
|
|
|
|
return 1;
|
2023-11-12 22:31:24 +09:00
|
|
|
}
|
2023-11-12 19:34:40 +09:00
|
|
|
}
|