int
board_load (window_board_t *win, char *fname)
{
FILE *f;
char buf[1024];
if (! (f = fopen (fname, "r")))
return 0;
if (fgets (buf, 1023, f) == NULL)
return 0;
int ret;
if (!strncmp(buf, "pn|", 3) || !strncmp(buf, "vg|", 3) ||
!strncmp(buf, "st|", 3) || !strncmp(buf, "qx|", 3)) {
ret = board_parse_lin (win, buf, f);
} else {
board *b = board_new (win->n_boards + 1);
ret = board_parse_line(buf, b, ' ', '.');
if (ret)
board_window_append_board (win, b);
else {
errno = EMEDIUMTYPE;
board_free (b);
}
}
int e = errno;
fclose(f);
if (ret) {
if (win->filename)
free (win->filename);
win->filename = strdup (fname);
}
errno = e;
return ret;
}
void board_hash_table_free(board_hash_table_t *table)
{
uint32_t i;
if(table == NULL)
return;
for(i = 0; i < table->size; i++) {
board_list_t *cur, *next;
cur = table->data[i];
if(cur == NULL)
break;
for(next = cur->next;
cur != NULL;
cur = next, next = next->next)
{
board_free(cur->item);
free(cur);
}
}
free(table->data);
free(table);
}
board_t *board_hash_table_insert(board_hash_table_t *table,
board_t *board)
{
board_t *board_new;
board_list_t *list = NULL, *list_new;
uint32_t index;
uint64_t hash, hash2;
if(table == NULL || board == NULL)
return NULL;
if(table->used >= ((table->size * 3) / 4)) {
board_hash_table_expand(table, table->size * 2);
}
hash = board_hash(board, &hash2);
index = hash & (table->size - 1);
list = table->data[index];
if(list != NULL) {
for(;;) {
if(list->hash == hash && list->hash2 == hash2
&& board_compare(list->item, board))
{
return list->item;
}
if(list->next == NULL)
break;
list = list->next;
}
}
board_new = board_clone(board);
if(board_new == NULL)
return NULL;
list_new = malloc(sizeof(*list_new));
if(list_new == NULL) {
board_free(board_new);
return NULL;
}
list_new->item = board_new;
list_new->hash = hash;
list_new->hash2 = hash2;
list_new->next = NULL;
if(list != NULL)
list->next = list_new;
else
table->data[index] = list_new;
table->used++;
return NULL;
}
int uct_play_random_game(Board * board, Color color) {
Color winner;
Board * clone = board_clone(board);
playout_random_game(clone, color);
winner = playout_find_winner(clone);
board_free(clone);
return winner == color;
}
int main(int argc, char **argv) {
if (argc < 3) {
printf("Usage: ./gol <infile> <print>\n");
return 0;
}
FILE *f = fopen(argv[1], "r");
int to_print = strtol(argv[2], NULL, 10);
// Check if we opened the file
if (f != NULL) {
int num_rows = 0;
int num_cols = 0;
int num_iterations = 0;
int num_pairs = 0;
double total_time = 0.0;
// read numbers
fscanf(f, "%d\n%d\n%d\n%d", &num_rows, &num_cols, &num_iterations, &num_pairs);
// set up board
board_t *board = init_board(f, num_rows, num_cols, num_pairs);
// set up timing
struct timeval start_time;
struct timeval end_time;
gettimeofday(&start_time, NULL);
// run iterations
int i = num_iterations;
while (board_next(board, &i)) {
if (to_print) {
print_board(board, num_iterations - i);
usleep(200000);
clear(num_rows + 4);
}
i--;
}
// get end time
gettimeofday(&end_time, NULL);
total_time = ((end_time.tv_sec + (end_time.tv_usec/1000000.0)) - (start_time.tv_sec + (start_time.tv_usec/1000000.0)));
// print final board
print_board(board, num_iterations);
printf("total time for %d iteration%s of %dx%d world is %f sec\n", num_iterations, (num_iterations != 1) ? "s" : "", num_rows, num_cols, total_time);
fclose(f);
board_free(board);
} else {
printf("There was an error opening '%s'\n", argv[1]);
return 1;
}
return 0;
}
/* tries opening a file in a temporary win structure, and displays errors if unable */
int
board_load_popup (window_board_t *win, int append, char *filename)
{
int i;
int ret = 0;
window_board_t *win1 = calloc (1, sizeof (window_board_t));
if (board_load (win1, filename)) {
if (append) {
int n = win->n_boards;
for (i = 0; i < win1->n_boards; i++)
board_window_append_board (win, win1->boards[i]);
if (win->n_boards > n) /* set to first new board */
win->cur = n;
} else {
MOVE_PTR (win->filename, win1->filename);
MOVE_PTR (win->title, win1->title);
MOVE_PTR (win->subtitle, win1->subtitle);
MOVE_PTR (win->team1, win1->team1);
MOVE_PTR (win->team2, win1->team2);
for (i = 0; i < win->n_boards; i++)
if (win->boards[i])
board_free (win->boards[i]);
win->boards = win1->boards;
win->n_boards = win1->n_boards;
win->n_boards_alloc = win1->n_boards_alloc;
win->cur = 0;
}
card_window_update(win->boards[win->cur]->dealt_cards);
show_board(win->boards[win->cur], REDRAW_FULL);
recently_used_add (filename);
ret = 1;
} else {
GtkWidget *error = gtk_message_dialog_new (GTK_WINDOW (win->window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
_("Error loading file '%s': %s"),
filename, g_strerror (errno));
gtk_dialog_run (GTK_DIALOG (error));
gtk_widget_destroy (error);
}
TRY_FREE (win1->filename);
TRY_FREE (win1->title);
TRY_FREE (win1->subtitle);
TRY_FREE (win1->team1);
TRY_FREE (win1->team2);
free (win1);
return ret;
}
Pos uct_search(Board * board, Color color) {
int i;
UCTNode * root, * ptr;
Board * clone;
Pos best_move;
root = uct_node_new(nil);
create_children(root, board, color);
LOOP(i, UCT_SIMULATIONS) {
clone = board_clone(board);
uct_simulate(root, clone, color);
//board_print(clone, stdout);
board_free(clone);
}
AIMoves *ai_threats(const Board *original)
{
AIMoves *moves;
AIWEIGHT u_sum = 0;
int i;
b = board_new();
board_copy(original, b);
/* Clear threat tallys */
for (i = 0; i < connect_k; i++) {
threat_counts[i][0] = 0;
threat_counts[i][1] = 0;
}
/* Horizontal lines */
for (i = 0; i < board_size; i++)
u_sum += threat_line(0, i, 1, 0);
/* Vertical lines */
for (i = 0; i < board_size; i++)
u_sum += threat_line(i, 0, 0, 1);
/* SE diagonals */
for (i = 0; i < board_size - connect_k + 1; i++)
u_sum += threat_line(i, 0, 1, 1);
for (i = 1; i < board_size - connect_k + 1; i++)
u_sum += threat_line(0, i, 1, 1);
/* SW diagonals */
for (i = connect_k - 1; i < board_size; i++)
u_sum += threat_line(i, 0, -1, 1);
for (i = 1; i < board_size - connect_k + 1; i++)
u_sum += threat_line(board_size - 1, i, -1, 1);
moves = ai_marks(b, PIECE_THREAT(1));
moves->utility = u_sum;
board_free(b);
return moves;
}
void ui_terminate_game ()
{
// FIXME: are we sure -1 is an invalid value?
if (animate_tag >= 0)
{
gtk_timeout_remove (animate_tag);
animate_tag = -1;
}
if (game_single_player)
prefs_save_scores (menu_get_game_name_with_level());
board_free ();
reset_game_params ();
if (opt_infile)
{
fclose (opt_infile);
opt_infile = NULL;
}
if (game_reset_uistate) game_reset_uistate();
sb_reset_human_time ();
sb_update();
ui_stopped = TRUE;
ui_cheated = FALSE;
}
/*
static char
game (char **board)
{
int round, i, j, l, ref;
char buffer[BUFFER_SIZE];
for (round = 0; round < (m * n); round++)
{
i = 0;
system ("clear");
printf ("Number of stone to align to win (k) = %d\n\n", k);
board_print (board);
do
{
printf ("\nPlayer '%c' give your move 'line column' (eg: 1 2),"
" press 'Q' to quit:\n ",
(round % 2 == 0 ? PLAYER1 : PLAYER2));
fgets (buffer, BUFFER_SIZE, stdin);
clean (buffer);
char *clean = strtok (buffer, ",. - ");
while (clean != NULL)
{
if (isdigit (clean[0]))
{
if (l == 0)
i = str2index (clean);
else if (l == 0)
j = str2index (clean);
else
printf (" Too much argument \n"
"The first two parameters will be used\n");
l++;
}
if (isalpha (clean[0]))
if (clean[0] == 'q' || clean[0] == 'Q')
return (EXIT_SUCCESS);
clean = strtok (NULL, " ,.-");
}
if (next >= 2)
ref =
board_set ((round % 2 == 0 ? PLAYER1 : PLAYER2), i, j, board);
else
printf ("Not enought argument. Try again please.\n");
}
while ((ctrl != 0) || (next < 2));
if (is_winner (board) != NONE)
return (is_winner (board));
}
return NONE;
}
*/
int
main (int argc, char **argv)
{
int optc;
static struct option long_opts[] = {
/* These options do not set a flag.
We distinguish them by their indices. */
{"verbose", no_argument, NULL, 'v'},
{"set-m", required_argument, NULL, 'm'},
{"set-n", required_argument, NULL, 'n'},
{"set-k", required_argument, NULL, 'k'},
{"all-ai", no_argument, NULL, '0'},
{"player1-ai", no_argument, NULL, '1'},
{"player2-ai", no_argument, NULL, '2'},
{"contest", required_argument, NULL, 'c'},
{"version", no_argument, NULL, 'V'},
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0},
};
while ((optc =
getopt_long (argc, argv, "m:n:k:012c:vVh", long_opts, NULL)) != -1)
{
switch (optc)
{
case 'm':
case 'n':
case 'k':
check_and_set (optc, atoi (optarg));
break;
case '0':
printf ("set both players to be an AI\n");
break;
case '1':
printf ("set first player as an AI\n");
break;
case '2':
printf ("set second player as an AI\n");
break;
case 'c':
printf ("enable 'contest mode'\n");
break;
case 'v':
verbose = true;
break;
case 'V':
version ();
break;
case 'h':
usage (EXIT_SUCCESS);
break;
default:
usage (EXIT_FAILURE);
}
}
board = board_alloc ();
//char bo = game(board);
board_free (board);
return (EXIT_SUCCESS);
}
int main(int argc, char* argv[]) {
struct arguments arguments;
struct board board;
char buffer[256];
int format;
char input;
char* message;
int status; // Game status.
struct termios term_settings;
int valid;
// Parse arguments.
message = arguments_parse(&arguments, argc, argv);
if (message) {
usage_print(message);
}
// Apply arguments.
valid = 1; // Hack; overload to determine whether to play or quit.
if (arguments.flags & ARGUMENTS_VERSION) {
printf("%s\n", VERSION);
valid = 0;
}
if (arguments.flags & ARGUMENTS_LEGAL) {
printf("%s\n", legal);
valid = 0;
}
if (arguments.flags & ARGUMENTS_HELP) {
usage_print(NULL);
}
if (!valid) {
exit(EXIT_SUCCESS);
}
if (arguments.flags & ARGUMENTS_MODE) {
if (arguments.mode == mode_format) {
setup_signal_handlers();
enter_alternate_buffer();
enter_format_mode(&term_settings);
format = 1;
} else if (arguments.mode == mode_plain) {
format = 0;
}
} else if (isatty(STDOUT_FILENO) && isatty(STDIN_FILENO)) {
setup_signal_handlers();
enter_alternate_buffer();
enter_format_mode(&term_settings);
format = 1;
}
if (arguments.flags & ARGUMENTS_SEED) {
srand(arguments.seed);
} else {
srand(time(NULL));
}
// Set up the board.
board_init(&board);
if (!format) {
fputs(legal, stdout);
}
// Play the game.
play:
valid = 1;
while (!(status = board_done(&board))) {
// Set up screen for next move.
// Sorry about this ugly call.
screen_print(&board, valid ? (format ? "\n\n" : "") :
"\nInvalid move.\n", format);
// Get the player's move.
input = yoink(format);
// Process player's move.
if (input == 'w' || input == 'k') {
valid = board_move_up(&board);
} else if (input == 's' || input == 'j') {
valid = board_move_down(&board);
} else if (input == 'a' || input == 'h') {
valid = board_move_left(&board);
} else if (input == 'd' || input == 'l') {
valid = board_move_right(&board);
} else if (input == 'n') {
// Start a new game (or not) based on user input.
printf("Start a new game? [y/N] ");
input = yoink(format);
if (input == 'y' || input == 'Y') {
board_reset(&board);
}
continue;
} else if (input == '?') {
help_print();
if (format) {
printf("\nPress any key to continue.");
input = yoink(format);
}
continue;
} else {
valid = 0;
}
// End player's move.
if (valid) {
board_plop(&board);
}
}
// Print the final board.
snprintf(buffer, sizeof(buffer),
"\nGame over, you %s!\n\nPlay again? [y/n]\n",
(status < 0) ? "LOSE" : "WIN");
screen_print(&board, buffer, format);
// Check for new game.
while ((input = yoink(format)) != 'y' && input != 'Y' &&
input != 'n' && input != 'N') {
screen_print(&board, buffer, format);
}
if (input == 'y' || input == 'Y') {
board_reset(&board);
goto play;
}
// Restore the terminal.
if (format) {
restore_mode();
leave_alternate_buffer();
}
// Free the board.
board_free(&board);
// Return success.
return EXIT_SUCCESS;
}
